რა არის DRF viewsets და routers?

Question

Accepted Answer

Django REST Framework-ში, **viewsets** აჯამებს დაკავშირებული API endpoints-ების ერთობლიობის ლოგიკას (რესურსის CRUD ოპერაციებს) ერთ კლასში, ხოლო **routers** ავტომატურად აგენერირებს მათ URL маршrutизაციას. ერთად ისინი მნიშვნელოვნად ამცირებენ boilerplate-ს RESTful API-ების აგებისას.

## ModelViewSet — სრული CRUD რამდენიმე ხაზში

```python
from rest_framework import viewsets

class ArticleViewSet(viewsets.ModelViewSet):
    queryset = Article.objects.all()             # the data
    serializer_class = ArticleSerializer          # how to serialize it
    # That's it! This provides ALL standard CRUD endpoints automatically:
    #   list (GET), create (POST), retrieve (GET /id), update (PUT/PATCH /id), destroy (DELETE /id)
```

`ModelViewSet` ავტომატურად უზრუნველყოფს **RESTful CRUD endpoints-ების სრულ ნაკრებს** მოდელისთვის — list, create, retrieve, update, partial update და delete — მხოლოდ queryset და serializer-ის საფუძველზე. არ არის საჭირო ყოველი view-ის ცალკე დაწერა.

## Routers — ავტომატური URL გენერაცია

```python
from rest_framework.routers import DefaultRouter

router = DefaultRouter()
router.register(r"articles", ArticleViewSet)     # register the viewset

urlpatterns = router.urls
# automatically creates the RESTful URLs:
#   GET    /articles/        → list
#   POST   /articles/        → create
#   GET    /articles/{id}/   → retrieve
#   PUT    /articles/{id}/   → update
#   PATCH  /articles/{id}/   → partial update
#   DELETE /articles/{id}/   → destroy
```

**router** ავტომატურად ასახავს viewset-ს სტანდარტული RESTful URL-ების სრულ ნაკრებზე — ერთი viewset-ის რეგისტრაცია აგენერირებს ყველა ჩვეულებრივ endpoint-ს სწორი HTTP მეთოდებით, აღმოფხვრის ხელით URL კონფიგურაციას.

## Viewsets-ის კასტომიზაცია

```python
class ArticleViewSet(viewsets.ModelViewSet):
    serializer_class = ArticleSerializer
    permission_classes = [IsAuthenticated]        # authorization

def get_queryset(self):                        # customize the data per request
        return Article.objects.filter(author=self.request.user)

# add CUSTOM endpoints beyond CRUD with @action
    @action(detail=True, methods=["post"])
    def publish(self, request, pk=None):           # POST /articles/{id}/publish/
        article = self.get_object()
        article.published = True
        article.save()
        return Response({"status": "published"})
```

Viewsets-ი კასტომიზირდება მეთოდების გადაფარვით (`get_queryset`, `perform_create`), ნებართვების დაყენებით და **custom actions**-ის დამატებით (`@action`) სტანდარტული CRUD-ის მიღმა endpoint-ებისთვის.

## Viewsets vs generic API views

```text
ModelViewSet  → ALL CRUD in one class + router → least code for standard REST resources
Generic views (ListCreateAPIView, etc.) → more explicit, one class per endpoint group
APIView       → full manual control for non-standard/custom endpoints
→ Use viewsets+routers for conventional REST resources; generic/APIView for custom needs.
```

## რატომ არის ეს მნიშვნელოვანი

Viewsets და routers არის DRF-ის მძლავრი ფিჩა RESTful API-ების ეფიკასურად აგებისთვის — ისინი წარმოადგენენ აბსტრაქციის უმაღლეს დონეს უაღრესად ხშირი შემთხვევისთვის, როდესაც მოდელი ხდება სრული REST რესურსი, და მათი გაგება ღირებული ჩანს პროდუქტიული API დეველოპმენტის კუთხით.

მთავარი სარგებელი არის მკრთალი **boilerplate შემცირება**: `ModelViewSet` პლუს router მოგცემთ სრულ, კონვენციონალურ REST API-ს რესურსისთვის (ყველა CRUD endpoint მართებული HTTP მეთოდებით და URL-ებით) მხოლოდ queryset და serializer-ის საფუძველზე — ჩანაცვლებს რა თუ არა ბევრ ცალკე views და ხელით URL patterns-ებს.

ეს სტანდარტული REST API-ების აგებას საოცრად სწრაფს ხდის, ხოლო **RESTful კონვენციების** შენარჩუნება (თანმიმდევრული URL სტრუქტურა და HTTP მეთოდის სემანტიკა) ავტომატურად ხორციელდება.

Viewsets რჩება მოქნილი — თქვენ მათ კასტომიზირებთ მეთოდების გადაფარვით (queryset ფილტრაცია მომხმარებელზე, ნებართვების კონტროლი, create/update-ში შეყოვნება) და **custom actions**-ის დამატებით (`@action`) ძირითადი CRUD-ის მიღმა endpoint-ებისთვის.

Viewsets და routers-ის გაგება, როგორ აგენერირებენ ისინი endpoint-ებს, როგორ აკასტომიზირებთ მათ და **როდის გამოიყენოთ მათი** (კონვენციონალური REST რესურსები) წინააღმდეგ უფრო ცხადი generic views ან APIView-ის (კასტომური/არასტანდარტული endpoint-ები) მიმართ, არის მნიშვნელოვანი პრაქტიკული ცოდნა DRF დეველოპმენტისთვის.

ვინაიდან REST API-ების აგება არის Django-ს პირველადი გამოყენება დღეს, და viewsets+routers არის იდიომატური, ყველაზე პროდუქტიული გზა ამისთვის სტანდარტული რესურსებისთვის, ისინი ხშირად გამოყენებული, მნიშვნელოვანი ნაწილია DRF toolkit-ის, რომელიც დეველოპერებს სთავაზნობს მძლავრი API-ების აგებას მინიმალური კოდით, ხოლო კასტომური მოთხოვნების გამკლავების გამრთელი დატოვებული დატოვებული.