Módulo 5: Autenticación, permisos y operaciones empresariales

¿Funciona el botón?

¿Quién inició sesión?
¿Qué operación intenta realizar?
¿Tiene permiso?
¿Puede acceder a este registro específico?
¿La operación mantiene la base de datos consistente?
¿Queda evidencia de lo ocurrido?

Control de acceso
├── autenticación
├── grupos
├── permisos
└── propiedad de registros

Operaciones empresariales
├── venta
├── detalles
├── existencias
├── movimientos
├── cancelación
└── auditoría

Venta
├── crear encabezado
├── crear detalles
├── comprobar existencias
├── descontar productos
├── registrar movimientos
└── calcular total

¿Quién eres?

¿Qué puedes hacer?

Ana inicia sesión correctamente        → autenticada
Ana intenta cancelar una venta         → requiere autorización
Ana no posee ese permiso               → respuesta 403

AUTH_USER_MODEL = "cuentas.Usuario"

from django.contrib.auth import get_user_model


Usuario = get_user_model()

from django.conf import settings


usuario = models.ForeignKey(
    settings.AUTH_USER_MODEL,
    on_delete=models.PROTECT,
)

usuario.password = "Clave123"
usuario.save()

usuario.set_password("una-clave-segura")
usuario.save()

Usuario.objects.create_user(
    username="vendedor1",
    email="vendedor1@example.com",
    password="una-clave-segura",
)

usuario.check_password("una-clave-segura")

from django import forms
from django.contrib.auth.forms import UserCreationForm
from django.contrib.auth import get_user_model


Usuario = get_user_model()


class RegistroUsuarioForm(UserCreationForm):
    class Meta(UserCreationForm.Meta):
        model = Usuario
        fields = (
            "username",
            "first_name",
            "last_name",
            "email",
        )

    def clean_email(self):
        email = self.cleaned_data["email"].strip().lower()

        if Usuario.objects.filter(email__iexact=email).exists():
            raise forms.ValidationError(
                "Ya existe una cuenta asociada a este correo."
            )

        return email

from django.contrib.auth.decorators import permission_required
from django.contrib.auth.models import Group
from django.contrib import messages
from django.shortcuts import redirect, render


@permission_required(
    "cuentas.add_usuario",
    raise_exception=True,
)
def usuario_crear(request):
    formulario = RegistroUsuarioForm(
        request.POST or None
    )

    if request.method == "POST" and formulario.is_valid():
        usuario = formulario.save()

        grupo = Group.objects.get(name="Vendedores")
        usuario.groups.add(grupo)

        messages.success(
            request,
            "La cuenta de vendedor fue creada.",
        )
        return redirect("cuentas:usuario_lista")

    return render(
        request,
        "cuentas/usuarios/formulario.html",
        {"form": formulario},
    )

# urls.py principal
from django.urls import include, path


urlpatterns = [
    path(
        "cuentas/",
        include("django.contrib.auth.urls"),
    ),
]

cuentas/login/
cuentas/logout/
cuentas/password_change/
cuentas/password_reset/

templates/registration/login.html

{% extends "base.html" %}

{% block title %}Iniciar sesión{% endblock %}

{% block content %}
<div class="container py-5">
    <div class="row justify-content-center">
        <div class="col-12 col-md-7 col-lg-5">
            <h1>Iniciar sesión</h1>

            {% if form.errors %}
                <div class="alert alert-danger" role="alert">
                    No fue posible iniciar sesión con esos datos.
                </div>
            {% endif %}

            <form method="post" class="card card-body shadow-sm">
                {% csrf_token %}
                {{ form.as_p }}

                {% if next %}
                    <input type="hidden" name="next" value="{{ next }}">
                {% endif %}

                <button class="btn btn-primary" type="submit">
                    Iniciar sesión
                </button>
            </form>
        </div>
    </div>
</div>
{% endblock %}

LOGIN_REDIRECT_URL = "/panel/"
LOGOUT_REDIRECT_URL = "/cuentas/login/"

{% if user.is_authenticated %}
    <form
        method="post"
        action="{% url 'logout' %}"
        class="d-inline"
    >
        {% csrf_token %}
        <button class="btn btn-link nav-link" type="submit">
            Cerrar sesión
        </button>
    </form>
{% endif %}

registration/password_change_form.html
registration/password_change_done.html

Solicitar recuperación
        ↓
mensaje enviado
        ↓
enlace con identificador y token
        ↓
definir nueva contraseña
        ↓
confirmación

registration/password_reset_form.html
registration/password_reset_done.html
registration/password_reset_email.html
registration/password_reset_subject.txt
registration/password_reset_confirm.html
registration/password_reset_complete.html

EMAIL_BACKEND = "django.core.mail.backends.console.EmailBackend"
DEFAULT_FROM_EMAIL = "no-responder@coa.local"

class PerfilUsuario(models.Model):
    usuario = models.OneToOneField(
        settings.AUTH_USER_MODEL,
        on_delete=models.CASCADE,
        related_name="perfil",
    )
    telefono = models.CharField(max_length=25, blank=True)
    puesto = models.CharField(max_length=80, blank=True)
    fotografia = models.ImageField(
        upload_to="perfiles/%Y/%m/",
        blank=True,
    )

    def __str__(self):
        return f"Perfil de {self.usuario.username}"

perfil, _ = PerfilUsuario.objects.get_or_create(
    usuario=request.user
)

from django.contrib.auth.decorators import login_required


@login_required
def panel(request):
    ...

from django.contrib.auth.decorators import permission_required


@permission_required(
    "inventario.change_producto",
    raise_exception=True,
)
def producto_editar(request, slug):
    ...

app_label.codename

inventario.view_producto
inventario.add_producto
inventario.change_producto
inventario.delete_producto

from django.contrib.auth.mixins import (
    LoginRequiredMixin,
    PermissionRequiredMixin,
)


class ProductoUpdateView(
    LoginRequiredMixin,
    PermissionRequiredMixin,
    UpdateView,
):
    permission_required = "inventario.change_producto"
    raise_exception = True

permission_required = (
    "inventario.view_producto",
    "inventario.change_producto",
)

add
change
delete
view

Grupo Vendedores
├── view_cliente
├── view_producto
├── add_venta
└── view_venta

from django.contrib.auth.models import Group


grupo = Group.objects.get(name="Vendedores")
usuario.groups.add(grupo)

usuario.has_perm("ventas.add_venta")

class Venta(models.Model):
    # campos

    class Meta:
        permissions = [
            (
                "cancelar_venta",
                "Puede cancelar ventas confirmadas",
            ),
            (
                "ver_todas_las_ventas",
                "Puede consultar todas las ventas",
            ),
        ]

python manage.py makemigrations
python manage.py migrate

from django.contrib.auth.models import Group, Permission
from django.core.management.base import BaseCommand


ROLES = {
    "Administradores": [
        "cuentas.view_usuario",
        "cuentas.add_usuario",
        "cuentas.change_usuario",
        "cuentas.view_perfilusuario",
        "cuentas.change_perfilusuario",
        "inventario.view_producto",
        "inventario.add_producto",
        "inventario.change_producto",
        "inventario.view_cliente",
        "inventario.add_cliente",
        "inventario.change_cliente",
        "ventas.view_venta",
        "ventas.add_venta",
        "ventas.cancelar_venta",
        "ventas.ver_todas_las_ventas",
    ],
    "Vendedores": [
        "cuentas.view_perfilusuario",
        "cuentas.change_perfilusuario",
        "inventario.view_producto",
        "inventario.view_cliente",
        "inventario.add_cliente",
        "inventario.change_cliente",
        "ventas.view_venta",
        "ventas.add_venta",
    ],
    "Inventario": [
        "cuentas.view_perfilusuario",
        "cuentas.change_perfilusuario",
        "inventario.view_producto",
        "inventario.add_producto",
        "inventario.change_producto",
        "inventario.view_movimientoinventario",
    ],
}


class Command(BaseCommand):
    help = "Crea o actualiza los roles empresariales"

    def handle(self, *args, **options):
        for nombre, etiquetas in ROLES.items():
            grupo, _ = Group.objects.get_or_create(name=nombre)
            permisos = []

            for etiqueta in etiquetas:
                app_label, codename = etiqueta.split(".", 1)
                permiso = Permission.objects.get(
                    content_type__app_label=app_label,
                    codename=codename,
                )
                permisos.append(permiso)

            grupo.permissions.set(permisos)

            self.stdout.write(
                self.style.SUCCESS(
                    f"Rol actualizado: {nombre}"
                )
            )

{% if perms.ventas.add_venta %}
    <a class="btn btn-primary" href="{% url 'ventas:crear' %}">
        Registrar venta
    </a>
{% endif %}

@permission_required("ventas.add_venta", raise_exception=True)
def venta_crear(request):
    ...

Template → muestra opciones apropiadas
Servidor  → decide si la operación está autorizada

class VentaListView(
    LoginRequiredMixin,
    PermissionRequiredMixin,
    ListView,
):
    model = Venta
    permission_required = "ventas.view_venta"
    raise_exception = True

    def get_queryset(self):
        queryset = (
            Venta.objects
            .select_related("cliente", "vendedor")
            .order_by("-creada_en")
        )

        if self.request.user.has_perm(
            "ventas.ver_todas_las_ventas"
        ):
            return queryset

        return queryset.filter(vendedor=self.request.user)

def get_queryset(self):
    queryset = super().get_queryset()

    if self.request.user.has_perm(
        "ventas.ver_todas_las_ventas"
    ):
        return queryset

    return queryset.filter(vendedor=self.request.user)

Puede cambiar productos
Puede ver ventas

Puede ver esta venta porque la creó

templates/403.html

{% extends "base.html" %}

{% block title %}Acceso denegado{% endblock %}

{% block content %}
<main class="container py-5">
    <h1>No tienes permiso para realizar esta operación</h1>
    <p>
        Si consideras que necesitas acceso, comunícate con la
        persona responsable del sistema.
    </p>
    <a class="btn btn-primary" href="{% url 'panel' %}">
        Volver al panel
    </a>
</main>
{% endblock %}

Vendedor
✓ consultar productos
✓ administrar clientes
✓ registrar ventas
✓ ver ventas propias
✗ editar existencias directamente
✗ cancelar ventas
✗ administrar usuarios

import uuid

from django.conf import settings
from django.core.validators import MinValueValidator
from django.db import models


class Venta(models.Model):
    class Estado(models.TextChoices):
        BORRADOR = "BORRADOR", "Borrador"
        CONFIRMADA = "CONFIRMADA", "Confirmada"
        CANCELADA = "CANCELADA", "Cancelada"

    numero = models.UUIDField(
        default=uuid.uuid4,
        unique=True,
        editable=False,
    )
    cliente = models.ForeignKey(
        "inventario.Cliente",
        on_delete=models.PROTECT,
        related_name="ventas",
    )
    vendedor = models.ForeignKey(
        settings.AUTH_USER_MODEL,
        on_delete=models.PROTECT,
        related_name="ventas_registradas",
    )
    estado = models.CharField(
        max_length=12,
        choices=Estado.choices,
        default=Estado.BORRADOR,
    )
    total = models.DecimalField(
        max_digits=12,
        decimal_places=2,
        default=0,
        validators=[MinValueValidator(0)],
    )
    creada_en = models.DateTimeField(auto_now_add=True)
    actualizada_en = models.DateTimeField(auto_now=True)
    cancelada_en = models.DateTimeField(null=True, blank=True)
    cancelada_por = models.ForeignKey(
        settings.AUTH_USER_MODEL,
        on_delete=models.PROTECT,
        null=True,
        blank=True,
        related_name="ventas_canceladas",
    )
    motivo_cancelacion = models.CharField(
        max_length=250,
        blank=True,
    )

    class Meta:
        ordering = ["-creada_en"]
        permissions = [
            (
                "cancelar_venta",
                "Puede cancelar ventas confirmadas",
            ),
            (
                "ver_todas_las_ventas",
                "Puede consultar todas las ventas",
            ),
        ]

    def __str__(self):
        return str(self.numero)

class DetalleVenta(models.Model):
    venta = models.ForeignKey(
        Venta,
        on_delete=models.CASCADE,
        related_name="detalles",
    )
    producto = models.ForeignKey(
        "inventario.Producto",
        on_delete=models.PROTECT,
        related_name="detalles_venta",
    )
    cantidad = models.PositiveIntegerField(
        validators=[MinValueValidator(1)]
    )
    precio_unitario = models.DecimalField(
        max_digits=10,
        decimal_places=2,
        validators=[MinValueValidator(0)],
    )

    class Meta:
        constraints = [
            models.UniqueConstraint(
                fields=["venta", "producto"],
                name="venta_producto_no_repetido",
            ),
            models.CheckConstraint(
                condition=models.Q(cantidad__gt=0),
                name="detalle_cantidad_positiva",
            ),
            models.CheckConstraint(
                condition=models.Q(precio_unitario__gte=0),
                name="detalle_precio_no_negativo",
            ),
        ]

    @property
    def subtotal(self):
        return self.cantidad * self.precio_unitario

    def __str__(self):
        return f"{self.venta} - {self.producto}"

class MovimientoInventario(models.Model):
    # campos existentes

    venta = models.ForeignKey(
        "ventas.Venta",
        on_delete=models.PROTECT,
        related_name="movimientos",
        null=True,
        blank=True,
    )

Producto.existencias → ¿cuánto hay ahora?
Movimientos          → ¿por qué cambió?

Todas se confirman
o
Todas se revierten

✓ venta creada
✓ primer detalle creado
✗ segundo producto sin stock
? venta parcial
? inventario parcialmente descontado

falla cualquier paso
        ↓
rollback completo
        ↓
no queda venta parcial

from django.db import transaction


@transaction.atomic
def operacion():
    ...

with transaction.atomic():
    ...

transaction.on_commit(
    lambda: notificar_venta(venta.pk)
)

from django import forms
from django.forms import BaseFormSet, formset_factory

from inventario.models import Cliente, Producto


class VentaForm(forms.Form):
    cliente = forms.ModelChoiceField(
        queryset=Cliente.objects.filter(activo=True),
        label="Cliente",
    )


class LineaVentaForm(forms.Form):
    producto = forms.ModelChoiceField(
        queryset=Producto.objects.filter(activo=True),
        label="Producto",
    )
    cantidad = forms.IntegerField(
        min_value=1,
        max_value=9999,
        label="Cantidad",
    )


class BaseLineaVentaFormSet(BaseFormSet):
    def clean(self):
        super().clean()

        if any(self.errors):
            return

        productos = set()

        for formulario in self.forms:
            if not formulario.cleaned_data:
                continue

            producto = formulario.cleaned_data.get("producto")

            if producto in productos:
                raise forms.ValidationError(
                    "No repitas un producto. Ajusta su cantidad."
                )

            productos.add(producto)


LineaVentaFormSet = formset_factory(
    LineaVentaForm,
    formset=BaseLineaVentaFormSet,
    extra=3,
    min_num=1,
    validate_min=True,
    max_num=20,
    validate_max=True,
)

from decimal import Decimal

from django.core.exceptions import ValidationError
from django.db import transaction
from django.db.models import F

from inventario.models import (
    Cliente,
    MovimientoInventario,
    Producto,
)
from .models import DetalleVenta, Venta


@transaction.atomic
def registrar_venta(*, cliente, vendedor, lineas):
    if not lineas:
        raise ValidationError("La venta necesita productos.")

    try:
        cliente = Cliente.objects.get(
            pk=cliente.pk,
            activo=True,
        )
    except Cliente.DoesNotExist as error:
        raise ValidationError(
            "El cliente ya no está disponible."
        ) from error

    venta = Venta.objects.create(
        cliente=cliente,
        vendedor=vendedor,
        estado=Venta.Estado.BORRADOR,
    )

    total = Decimal("0.00")
    productos_utilizados = set()

    for linea in lineas:
        producto_id = linea["producto"].pk
        cantidad = linea["cantidad"]

        if not isinstance(cantidad, int) or cantidad <= 0:
            raise ValidationError(
                "Todas las cantidades deben ser positivas."
            )

        if producto_id in productos_utilizados:
            raise ValidationError(
                "Un producto aparece más de una vez."
            )
        productos_utilizados.add(producto_id)

        try:
            producto = (
                Producto.objects
                .select_for_update()
                .get(pk=producto_id, activo=True)
            )
        except Producto.DoesNotExist as error:
            raise ValidationError(
                "Uno de los productos ya no está disponible."
            ) from error

        actualizados = Producto.objects.filter(
            pk=producto.pk,
            activo=True,
            existencias__gte=cantidad,
        ).update(
            existencias=F("existencias") - cantidad
        )

        if actualizados != 1:
            raise ValidationError(
                f"No hay existencias suficientes de {producto.nombre}."
            )

        DetalleVenta.objects.create(
            venta=venta,
            producto=producto,
            cantidad=cantidad,
            precio_unitario=producto.precio,
        )

        MovimientoInventario.objects.create(
            producto=producto,
            tipo=MovimientoInventario.Tipo.SALIDA,
            cantidad=cantidad,
            motivo=f"Venta {venta.numero}",
            registrado_por=vendedor,
            venta=venta,
        )

        total += producto.precio * cantidad

    venta.total = total
    venta.estado = Venta.Estado.CONFIRMADA
    venta.save(
        update_fields=[
            "total",
            "estado",
            "actualizada_en",
        ]
    )

    return venta

existencias__gte=cantidad

actualizados = Producto.objects.filter(
    pk=producto.pk,
    existencias__gte=cantidad,
).update(
    existencias=F("existencias") - cantidad
)

if actualizados != 1:
    raise ValidationError("Existencias insuficientes.")

from django.contrib import messages
from django.contrib.auth.decorators import permission_required
from django.core.exceptions import ValidationError
from django.shortcuts import redirect, render


@permission_required(
    "ventas.add_venta",
    raise_exception=True,
)
def venta_crear(request):
    venta_form = VentaForm(request.POST or None)
    lineas_formset = LineaVentaFormSet(
        request.POST or None,
        prefix="lineas",
    )

    if (
        request.method == "POST"
        and venta_form.is_valid()
        and lineas_formset.is_valid()
    ):
        lineas = [
            formulario.cleaned_data
            for formulario in lineas_formset.forms
            if formulario.cleaned_data
        ]

        try:
            venta = registrar_venta(
                cliente=venta_form.cleaned_data["cliente"],
                vendedor=request.user,
                lineas=lineas,
            )
        except ValidationError as error:
            venta_form.add_error(
                None,
                " ".join(error.messages),
            )
        else:
            messages.success(
                request,
                "La venta se registró correctamente.",
            )
            return redirect("ventas:detalle", pk=venta.pk)

    return render(
        request,
        "ventas/formulario.html",
        {
            "form": venta_form,
            "lineas": lineas_formset,
        },
    )

<form method="post" class="card card-body shadow-sm">
    {% csrf_token %}
    {{ lineas.management_form }}

    {% if form.non_field_errors %}
        <div class="alert alert-danger" role="alert">
            {{ form.non_field_errors }}
        </div>
    {% endif %}

    {{ form.as_p }}

    <fieldset>
        <legend class="h4">Productos</legend>

        {% for linea in lineas %}
            <div class="row g-3 border-bottom py-3">
                <div class="col-12 col-md-8">
                    {{ linea.producto.label_tag }}
                    {{ linea.producto }}
                    {{ linea.producto.errors }}
                </div>
                <div class="col-12 col-md-4">
                    {{ linea.cantidad.label_tag }}
                    {{ linea.cantidad }}
                    {{ linea.cantidad.errors }}
                </div>
            </div>
        {% endfor %}

        {{ lineas.non_form_errors }}
    </fieldset>

    <button class="btn btn-primary mt-4" type="submit">
        Confirmar venta
    </button>
</form>

from django.utils import timezone


@transaction.atomic
def cancelar_venta(*, venta_id, usuario, motivo):
    motivo = motivo.strip()

    if len(motivo) < 10:
        raise ValidationError(
            "Explica el motivo con al menos 10 caracteres."
        )

    venta = (
        Venta.objects
        .select_for_update()
        .prefetch_related("detalles__producto")
        .get(pk=venta_id)
    )

    ahora = timezone.now()

    actualizadas = Venta.objects.filter(
        pk=venta.pk,
        estado=Venta.Estado.CONFIRMADA,
    ).update(
        estado=Venta.Estado.CANCELADA,
        cancelada_en=ahora,
        cancelada_por=usuario,
        motivo_cancelacion=motivo,
        actualizada_en=ahora,
    )

    if actualizadas != 1:
        raise ValidationError(
            "La venta ya no puede cancelarse."
        )

    for detalle in venta.detalles.all():
        Producto.objects.filter(
            pk=detalle.producto_id
        ).update(
            existencias=F("existencias") + detalle.cantidad
        )

        MovimientoInventario.objects.create(
            producto_id=detalle.producto_id,
            tipo=MovimientoInventario.Tipo.ENTRADA,
            cantidad=detalle.cantidad,
            motivo=f"Cancelación de venta {venta.numero}",
            registrado_por=usuario,
            venta=venta,
        )

    venta.refresh_from_db()
    return venta

class CancelarVentaForm(forms.Form):
    motivo = forms.CharField(
        min_length=10,
        max_length=250,
        widget=forms.Textarea(attrs={"rows": 4}),
        help_text="Explica por qué se cancela la operación.",
    )

@permission_required(
    "ventas.cancelar_venta",
    raise_exception=True,
)
def venta_cancelar(request, pk):
    venta = get_object_or_404(Venta, pk=pk)
    formulario = CancelarVentaForm(request.POST or None)

    if request.method == "POST" and formulario.is_valid():
        try:
            cancelar_venta(
                venta_id=venta.pk,
                usuario=request.user,
                motivo=formulario.cleaned_data["motivo"],
            )
        except ValidationError as error:
            formulario.add_error(
                None,
                " ".join(error.messages),
            )
        else:
            messages.success(
                request,
                "La venta fue cancelada y el inventario se restauró.",
            )
            return redirect("ventas:detalle", pk=venta.pk)

    return render(
        request,
        "ventas/confirmar_cancelacion.html",
        {"form": formulario, "venta": venta},
    )

class AuditoriaModel(models.Model):
    creado_en = models.DateTimeField(auto_now_add=True)
    actualizado_en = models.DateTimeField(auto_now=True)
    creado_por = models.ForeignKey(
        settings.AUTH_USER_MODEL,
        on_delete=models.PROTECT,
        related_name="%(app_label)s_%(class)s_creados",
    )

    class Meta:
        abstract = True

@login_required
def panel(request):
    contexto = {}

    if request.user.has_perm("ventas.add_venta"):
        contexto["ventas_propias_hoy"] = Venta.objects.filter(
            vendedor=request.user,
            creada_en__date=timezone.localdate(),
        ).count()

    if request.user.has_perm(
        "inventario.view_movimientoinventario"
    ):
        contexto["productos_bajo_minimo"] = Producto.objects.filter(
            activo=True,
            existencias__lte=F("stock_minimo"),
        ).count()

    if request.user.has_perm(
        "ventas.ver_todas_las_ventas"
    ):
        contexto["ventas_totales_hoy"] = Venta.objects.filter(
            creada_en__date=timezone.localdate(),
            estado=Venta.Estado.CONFIRMADA,
        ).count()

    return render(request, "panel/inicio.html", contexto)

{{ cliente.nombre }}

{{ comentario|safe }}

Producto.objects.filter(nombre__icontains=termino)

# Evitar
sql = f"SELECT * FROM producto WHERE nombre = '{termino}'"

Producto.objects.raw(
    "SELECT * FROM inventario_producto WHERE nombre = %s",
    [termino],
)

SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
SECURE_SSL_REDIRECT = True

Público
Interno
Confidencial
Restringido

Te daré roles, operaciones y reglas de propiedad.
Crea una matriz de acceso.

Para cada permiso:
- identifica recurso y acción;
- indica si es global o por propietario;
- propone prueba permitida y denegada;
- señala ambigüedades.

No concedas permisos por conveniencia.

Revisa estas URLs y vistas de Django 5.2.
Para cada ruta indica:
- método HTTP;
- autenticación;
- permiso;
- propiedad;
- CSRF;
- respuesta si se deniega;
- cambio de estado.

No asumas que ocultar un enlace protege la vista.

Analiza esta operación de venta.
Enumera todas las escrituras y los puntos de fallo.
Comprueba atomicidad, inventario negativo, duplicados,
concurrencia, cancelación y auditoría.
No propongas signals para ocultar la lógica principal.

Genera pruebas negativas para tres roles:
administrador, vendedor e inventario.
Incluye acceso directo por URL, POST manual, objeto ajeno,
doble envío, stock insuficiente y doble cancelación.
No marques ninguna prueba como aprobada sin ejecutarla.

registro controlado
→ login
→ sesión
→ permiso
→ objeto
→ operación
→ auditoría

Venta 1 ── N Detalles N ── 1 Producto
  │                         │
  └──────── N Movimientos ──┘