Proč a jak byste měli používat vlastní uživatelský model?

Question

Accepted Answer

Vlastní **uživatelský model** nahrazuje výchozího `User` z Djanga tak, aby vyhovoval potřebám vaší aplikace — přidáním polí, změnou identifikátoru pro přihlášení (např. e-mail místo uživatelského jména) nebo přizpůsobením chování. Důležitá a často opakovaná rada: nastavte vlastní uživatelský model **úplně na začátku** projektu, i když ještě nepotřebujete změny, protože jeho změna později je nesmírně obtížná.

## Proč: výchozí User je omezený a později se těžko mění

```text
The default User has fixed fields (username, email, first/last name) and uses
USERNAME as the login field. Real apps often need:
  ✓ Email-based login (no username)
  ✓ Extra fields (phone, avatar, role, preferences) on the user itself
  ✓ Custom authentication behavior
```

## Kritický důvod, proč to udělat NEJDŘÍV

```text
⚠️ Changing the user model AFTER migrations exist is VERY hard — the User model is
   referenced by auth, admin, sessions, foreign keys throughout the database.
   Swapping it later requires complex, risky data migrations.
→ ALWAYS define a custom user model at project START (before the first migration),
   even an empty one, so you can extend it freely later. Django's docs strongly
   recommend this for EVERY new project.
```

Toto je klíčová praktická lekcí: nastavení vlastního uživatelského modelu prvního dne stojí téměř nic, ale přidání jednoho do etablovaného projektu je velký a chybě náchylný podnik — takže to uděláte předem jako pojistku.

## Jak: rozšíření AbstractUser (snadný způsob)

```python
# models.py — add fields, keep Django's auth behavior
from django.contrib.auth.models import AbstractUser

class User(AbstractUser):
    phone = models.CharField(max_length=20, blank=True)
    avatar = models.ImageField(upload_to="avatars/", blank=True)
    is_premium = models.BooleanField(default=False)
```

```python
# settings.py — tell Django to use it
AUTH_USER_MODEL = "myapp.User"
```

`AbstractUser` si nechá všechna výchozí pole a autentizační mechaniku z Djanga — vy jenom přidáte pole. Nejjednoduší a nejčastější přístup.

## Jak: AbstractBaseUser (plná kontrola, např. přihlášení přes e-mail)

```python
from django.contrib.auth.models import AbstractBaseUser, BaseUserManager, PermissionsMixin

class User(AbstractBaseUser, PermissionsMixin):
    email = models.EmailField(unique=True)
    USERNAME_FIELD = "email"          # log in with EMAIL instead of username
    REQUIRED_FIELDS = []
    objects = CustomUserManager()     # a manager defining create_user/create_superuser
```

`AbstractBaseUser` vám dá úplnou kontrolu nad uživatelským modelem (např. odstranění uživatelského jména zcela pro přihlášení pouze přes e-mail) — více práce, ale maximální flexibilita.

## Správné odkazování na uživatelský model

```python
from django.conf import settings
from django.contrib.auth import get_user_model

# in models — reference via settings.AUTH_USER_MODEL
author = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)

# in code — get the active user model dynamically
User = get_user_model()              # NOT a direct import of the default User
```

Vždy se na uživatelský model odkazujte přes `settings.AUTH_USER_MODEL` (v modelech) a `get_user_model()` (v kódu), nikdy ne přímým importem výchozího `User` — aby váš kód fungoval s vlastním modelem.

## Proč to má smysl

Použivání vlastního uživatelského modelu je důležité vědomostí s kritickou, často zdůrazňovanou praktickou lekcí, kterou by měl každý Django vývojář internalizovat: **nastavte to úplně na začátku každého projektu**.

Důvod, proč na tom tolik záleží, je závažná asymetrie v obtížnosti — definování vlastního uživatelského modelu prvního dne (i když jen prázdná `AbstractUser` podtřída) stojí téměř nic a poskytuje neocenitelnou flexibilitu, zatímco přechod na vlastní uživatelský model *poté*, co má projekt migrace a data, je nesmírně obtížný a riskantní, protože uživatelský model je hluboko referenčně propojený v celém Djangu (autentizace, admin, relace) a cizími klíči v celé vaší databázi, což vyžaduje komplexní a chybě náchylné datové migrace pro změnu.

Proto Django vlastní dokumentace silně doporučuje vlastní uživatelský model pro každý nový projekt, bez ohledu na bezprostřední potřebu — je to pojistka proti budoucímu migračnímu nočnímu můru.

Beyond this critical timing advice, understanding *how* to create custom user models — **`AbstractUser`** for simply adding fields while keeping Django's auth behavior (the common, easy case), and **`AbstractBaseUser`** for full control like email-based login (removing username entirely) — is valuable for meeting real application requirements (extra user fields, alternative login identifiers, custom auth).

Rovněž důležité je vědět, že se na uživatelský model **odkazuje správně** (přes `settings.AUTH_USER_MODEL` a `get_user_model()`, nikdy přímý import), takže kód funguje s jakýmkoli nakonfigurovaným uživatelským modelem.

Protože téměř každá skutečná aplikace má uživatelské specifické potřeby nad rámec výchozích hodnot Djanga (a dokonce i ty, které nemusí, z flexibility těžit), a protože cena jejich raného nastavení je tak vysoká, porozumění vlastním uživatelským modelům — zvláště imperativu etablovat jeden na začátku projektu — je důležité, prakticky kritické vědomostí, které zabraňuje běžné a vážné chybě na úrovni projektu, čímž se stává často citovaným kuskem Django best-practice moudrosti.