நீங்கள் ஒரு கஸ்டம் யூசர் மாடலை ஏன் மற்றும் எப்படி பயன்படுத்த வேண்டும்?

Question

Accepted Answer

**கஸ்டம் யூசர் மாடல்** Django-ன் இயல்பான `User` மாதிரியை உங்கள் பயன்பாட்டின் தேவைகளுக்கு ஏற்றவாறு மாற்றுகிறது — புலங்களைச் சேர்ப்பது, உள்நுழைவு அடையாளத்தை மாற்றுவது (எ.கா., பயனர் பெயருக்குப் பதிலாக மின்னஞ்சல்) அல்லது நடத்தையைக் கொத்தனவாக்குவது. முக்கியமான, அடிக்கடி மீண்டும் கூறப்படும் ஆலோசனை: **திட்டத்தின் முற்றிலும் தொடக்கத்திலேயே** ஒரு கஸ்டம் யூசர் மாடலை அமைக்கவும், நீங்கள் இன்னும் மாற்றங்கள் தேவைப்பட்டாலும் கூட, ஏனெனில் பின்னர் அதை மாற்றுவது மிகவும் வேதனையாக இருக்கும்.

## இயல்பான User கட்டுப்படுத்தப்பட்டுள்ளது மற்றும் பின்னர் மாற்றுவது கடினம்

```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
```

## முதலில் இதைச் செய்ய வேண்டிய முக்கியமான காரணம்

```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.
```

இது முக்கிய நடைமுறை பாடம்: முதல் நாளிலேயே ஒரு கஸ்டம் யூசர் மாடலை அமைப்பது கிட்டத்தட்ட எதுவும் செலவாகாது, ஆனால் ஒரு நிறுவப்பட்ட திட்டத்திற்கு ஒன்றை மாற்றியமைப்பது ஒரு பெரிய, பிழைக்கு உள்ளாகக்கூடிய முயற்சி — எனவே நீங்கள் அதை முன்பாகவே செய்கிறீர்கள்保険 போல.

## எப்படி: AbstractUser-ஐ நீட்டிப்பது (எளிய வழி)

```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` Django-ன் அனைத்து இயல்பான புலங்கள் மற்றும் auth இயந்திரங்களைக் கொண்டுவருகிறது — நீங்கள் வெறுமனே புலங்களைச் சேர்க்க வேண்டும். எளிமையான, மிகவும் பொதுவான அணுகுமுறை.

## எப்படி: AbstractBaseUser (முழு கட்டுப்பாடு, எ.கா., மின்னஞ்சல் உள்நுழைவு)

```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` யூசர் மாடலின் மீது முழு கட்டுப்பாடு (எ.கா., மின்னஞ்சல்-மட்டுமே உள்நுழைவுக்கு பயனர் பெயரை முழுவதுமாக அகற்றுவது) — அதிக வேலை, ஆனால் அதிகபட்ச நমনீয়தை வழங்குகிறது.

## யூசர் மாடலைச் சரியாகக் குறிப்பிடுவது

```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
```

Yonஜஸர் மாடலை `settings.AUTH_USER_MODEL` (மாடல்களில்) மற்றும் `get_user_model()` (குறியீட்டில்) மூலம் குறிப்பிடுங்கள், எப்போதுமே `User`-ஐ நேரடியாக இறக்குமதி செய்யாதீர்கள் — எனவே உங்கள் குறியீடு கஸ்டம் மாடலுடன் வேலை செய்கிறது.

## ஏன் இது முக்கியமானது

கஸ்டம் யூசர் மாடலைப் பயன்படுத்துவது முக்கியமான அறிவுதான், மேலும் ஒரு முக்கியமான, அடிக்கடி வலியுறுத்தப்பட்ட நடைமுறை பாடம் உள்ளது, இது ஒவ்வொரு Django டெவலப்பரும் உள்வாங்கிக் கொள்ள வேண்டும்: **ஒவ்வொரு திட்டத்தின் முற்றிலும் தொடக்கத்திலேயே அதை அமைக்கவும்**.

இது மிகவும் முக்கியமான காரணம் கடினতার கடுமையான சமச்சீரற்றதன்மை — முதல் நாளிலேயே ஒரு கஸ்டம் யூசர் மாடலை வரையறுப்பது (ஒரு வெற்று `AbstractUser` subclass கூட) கிட்டத்தட்ட எதுவும் செலவாகாது மற்றும் விலையற்ற நமனீய்தை வழங்குகிறது, ஆனால் திட்டத்தில் migration மற்றும் தரவு இருந்த பின்னர் ஒரு கஸ்டம் யூசர் மாடலுக்கு மாறுவது மிகவும் வேதனையாக மற்றும் ஆபத்தாக இருக்கிறது, ஏனெனில் User மாடல் Django முழுவதும் (authentication, admin, sessions) மற்றும் உங்கள் முழு தரவுத்தளத்தில் வெளிநாட்டு விசைகளால் ஆழமாக குறிப்பிடப்பட்டுள்ளது, மாற்றத்திற்கு சிக்கலான, பிழைக்கு உள்ளாகக்கூடிய தரவு migration தேவைப்படுகிறது.

இதுவே Django-ன் சொந்த ஆவணங்கள் முறையான பயன்பாட்டு தேவை இல்லை இருந்தாலும், ஒவ்வொரு புதிய திட்டத்திற்கும் ஒரு கஸ்டம் யூசர் மாடலை வலுவாக பரிந்துரைக்கிற காரணம் — இது ஒரு வருங்கால migration nightmare க்கு எதிரான பீமா.

இந்த முக்கியமான நேர ஆலோசனையுடன் தவிர, கஸ்டம் யூசர் மாடல்களை எப்படி உருவாக்க வேண்டும் என்பதைப் புரிந்துகொள்வது — **`AbstractUser`** Django-ன் auth நடத்தையைக் கொண்டு வைத்துக் கொண்டே புலங்களைச் சேர்ப்பதற்கு (பொதுவான, எளிய வழக்கு), மற்றும் **`AbstractBaseUser`** மின்னஞ்சல்-அடிப்படையிலான உள்நுழைவு போன்ற முழு கட்டுப்பாட்டுக்கு (பயனர் பெயரை முழுவதுமாக அகற்றுவது) — உண்மையான பயன்பாட்டு தேவைகளை (கூடுதல் யூசர் புலங்கள், மாற்று உள்நுழைவு அடையாளங்கள், கஸ்டம் auth) பூர்த்திசெய்வதற்கு மதிப்புள்ளதாக இருக்கிறது.

சமान முக்கியத்துவம் உள்ளது யூசர் மாடலை **சரியாகக் குறிப்பிடுவதைப் பற்றி** அறிவது (`settings.AUTH_USER_MODEL` மற்றும் `get_user_model()` மூலம், நேரடி இறக்குமதி எப்போதுமில்லை) எனவே குறியீடு எந்த யூசர் மாடல் உள்ளமைவு உள்ளது என்பதுடன் வேலை செய்கிறது.

க்ரஹமாக ஒவ்வொரு உண்மையான பயன்பாட்டிற்கு Django-ன் defaults-ஐ விட அதிகமாக யூசர்-குறிப்பிட்ட தேவைகள் இருப்பதால் (மற்றும் அவை இல்லாதவை கூட நமனீய்தை பயன்பெறுகின்றன), மற்றும் இதை தொடக்கத்தில் அமைக்கா மாறாக செலவு மிகவும் அதிகமாக இருப்பதால், கஸ்டம் யூசர் மாடல்களைப் புரிந்துகொள்வது — குறிப்பாக திட்ட தொடக்கத்தில் ஒன்றை நிறுவ வேண்டிய கட்டளை — நடைமுறையாக-முக்கியமான அறிவு, இது ஒரு பொதுவான மற்றும் தீவிரமான திட்ட-நிலை தவறைத் தடுக்கிறது, Django சிறந்த-நடைமுறை ஞாணம் ஒரு அடிக்கடி-மேற்கோள் செய்யப்பட்ட அংশ ஆக்குகிறது.