Python

To implement a service inside the repository pattern, we can start by creating a service class for our model in a new services.py file. We can then modify the repository methods to use the service methods.

For example, let's say we want to create a service called MyModelService that handles some business logic for our model. We can code it like so:

python
 
 
Copy code
from .models import MyModel

class MyModelService:
    def create(self, data):
        my_model = MyModel.objects.create(
            field1=data.get('field1'),
            field2=data.get('field2'),
            field3=data.get('field3')
        )
        return my_model

    def get_all(self):
        return MyModel.objects.all()

    def get_by_id(self, id):
        return MyModel.objects.get(id=id)

    def update(self, my_model, data):
        my_model.field1 = data.get('field1', my_model.field1)
        my_model.field2 = data.get('field2', my_model.field2)
        my_model.field3 = data.get('field3', my_model.field3)
        my_model.save()
        return my_model

    def delete(self, my_model):
        my_model.delete()

Then, we can modify the repository methods to use the service methods like so:

python
 
 
Copy code
from .services import MyModelService

class MyModelRepository:
    def __init__(self):
        self.service = MyModelService()

    def create(self, data):
        my_model = self.service.create(data)
        return my_model

    def get_all(self):
        my_models = self.service.get_all()
        return my_models

    def get_by_id(self, id):
        my_model = self.service.get_by_id(id)
        return my_model

    def update(self, my_model, data):
        my_model = self.service.update(my_model, data)
        return my_model

    def delete(self, my_model):
        self.service.delete(my_model)

Finally, we can modify our Generic API views to use the repository and service classes like so:

python
 
 
Copy code
from rest_framework import generics
from rest_framework.response import Response

from .models import MyModel
from .serializers import MyModelSerializer
from .repositories import MyModelRepository

class MyModelListCreateAPIView(generics.ListCreateAPIView):
    serializer_class = MyModelSerializer
    queryset = MyModel.objects.all()
    repository = MyModelRepository()

    def create(self, request, *args, **kwargs):
        data = request.data
        my_model = self.repository.create(data)
        serializer = self.serializer_class(my_model)
        return Response(serializer.data, status=status.HTTP_201_CREATED)

    def get(self, request, *args, **kwargs):
        my_models = self.repository.get_all()
        serializer = self.serializer_class(my_models, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)

class MyModelRetrieveUpdateDestroyAPIView(generics.RetrieveUpdateDestroyAPIView):
    serializer_class = MyModelSerializer
    queryset = MyModel.objects.all()
    repository = MyModelRepository()

    def get_object(self):
        my_model_id = self.kwargs['pk']
        my_model = self.repository.get_by_id(my_model_id)
        return my_model

    def put(self, request, *args, **kwargs):
        my_model_id = self.kwargs['pk']
        my_model = self.repository.get_by_id(my_model_id)
        data = request.data
        updated_my_model = self.repository.update(my_model, data)
        serializer = self.serializer_class(updated_my_model)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def delete(self, request, *args, **kwargs):
        my_model_id = self.kwargs['pk']
        my_model = self.repository.get_by_id(my_model_id)
        self.repository.delete(my_model)
        return Response(status.HTTP_204_NO_CONTENT)

With these modifications, we have successfully implemented a service inside the repository pattern in Django Rest Framework, using Generic API views.

Python

We can implement the service layer inside the repository pattern that we created earlier. To do this, we’ll create a separate file called services.py inside the same directory as our repositories.py file. This is where we’ll define our service logic.

Here are the steps to implement the service layer inside the repository pattern using Generic API views in Django Rest Framework:

1. Import the necessary packages and modules as follows:

python
 
 
Copy code
from .repositories import MyModelRepository
from .models import MyModel

1. Define a service class called MyModelService:

python
 
 
Copy code
class MyModelService:
    def __init__(self):
        self.repository = MyModelRepository()

    def create(self, data):
        # Define custom service logic here
        return self.repository.create(data)

    def get_all(self):
        # Define custom service logic here
        return self.repository.get_all()

    def get_by_id(self, id):
        # Define custom service logic here
        return self.repository.get_by_id(id)

    def update(self, id, data):
        # Define custom service logic here
        instance = self.get_by_id(id)
        return self.repository.update(instance, data)

    def delete(self, id):
        # Define custom service logic here
        instance = self.get_by_id(id)
        return self.repository.delete(instance)

1. Modify your MyModelListCreateAPIView and MyModelRetrieveUpdateDestroyAPIView classes to use the MyModelService class:

python
 
 
Copy code
class MyModelListCreateAPIView(generics.ListCreateAPIView):
    serializer_class = MyModelSerializer
    service = MyModelService()

    def create(self, request, *args, **kwargs):
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        self.perform_create(serializer)
        headers = self.get_success_headers(serializer.data)
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)



    def list(self, request, *args, **kwargs):
        data = self.service.get_all()
        serializer = self.get_serializer(data, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)

class MyModelRetrieveUpdateDestroyAPIView(generics.RetrieveUpdateDestroyAPIView):
    serializer_class = MyModelSerializer
    service = MyModelService()

    def get_object(self):
        return self.service.get_by_id(self.kwargs['pk'])

    def update(self, request, *args, **kwargs):
        instance = self.get_object()
        serializer = self.get_serializer(instance, data=request.data)
        serializer.is_valid(raise_exception=True)
        self.perform_update(serializer)
        return Response(serializer.data)

With these changes, the repository pattern now uses the service layer to provide additional functionality and flexibility to our Generic API views. Note, that we only added a couple of methods that we can use to define our custom business logic. Any other custom methods that we define inside our service module can be called in the same way.

To use the repository pattern inside Django, we can simply import the appropriate API views and include them in the app's URLconf.