Menene viewsets da routers na DRF?

Question

Accepted Answer

In Django REST Framework, **viewsets** group the logic for a set of related API endpoints (the CRUD operations for a resource) into a single class, and **routers** automatically generate the URL routing for them. Together they dramatically reduce boilerplate for building RESTful APIs.

## ModelViewSet — complete CRUD in a few lines

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

A `ModelViewSet` automatically provides the **complete set of RESTful CRUD endpoints** for a model — list, create, retrieve, update, partial update, and delete — from just a queryset and serializer. No need to write each view separately.

## Routers — automatic URL generation

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

A **router** maps a viewset to a full set of standard RESTful URLs automatically — registering one viewset generates all the conventional endpoints with correct HTTP methods, eliminating manual URL configuration.

## Customizing 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 are customized by overriding methods (`get_queryset`, `perform_create`), setting permissions, and adding **custom actions** (`@action`) for endpoints beyond standard CRUD.

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

## Yme take yayi muhimma

Viewsets da routers sune abin karfi na DRF don gina APIs na RESTful da inganci — suna wakilta matsakaicin matakin abstraction don halin da ba sakamakon haba-haba na fallace musamman na fitarwa wata albarkatacciyar model azaman cikakken yar'ar REST, kuma fahimta su yana da daraja ga halin ci gaba na abubuwan API.

Babbar fa'idar ita ce raging karamin **boilerplate**: `ModelViewSet` plus router yana ba ka cikakken, daidai tsohon API na REST don albarkatacciya (duk endpoints na CRUD tare da daidai bang HTTP da URLs) daga queryset da serializer kawai — maye gurbin abin da ba haka zaune zai kasance bayani da yawa da bakin daftari da lechiyin URL na nan nan.

Ya sa ginin daidai tsohon APIs na REST sannu-sannu sauri sosai yayin da ba da anfaninsa a kirji **RESTful conventions** (hauhawa na launi URL da yanayin halayen HTTP) jiya kain.

Viewsets suna zama mabambarame — kuke daidaita su ta hanyar rungumi hanyoyi (`get_queryset`, `perform_create`), saita izini, da kara **ayyukan kirki** (`@action`) don endpoints sama da standard CRUD.

Ganin viewsets da routers, yadda suke samarwa endpoints, yadda aka customizing su, da **jiya a yi amfani dasu** (yar'arran daidai tsohon REST) a takwas da halin jari generic views ko APIView (leche/ba daidai endpoints) — ilimin gida muhimmu ne don ci gaban DRF.

Don gida cewa gina APIs na REST shine babbar amfani da Django a jiya, da viewsets+routers ne hanyar jiya ta so ita ce mafi sauri don abubuwan daidai tsohon, sai da su sune abin da aka yi amfani da yawa, muhimmancin sassa na gabashin DRF wanda ke ba masu sarrafa masu karfi API tare da karame kodayake sannan ka tura gida a ba ta abubuwan kirki.