Radoslav Georgiev - Django structure for scale and longevity

Introduction

This tutorial provides a structured approach to building scalable and maintainable Django applications, drawing from Radoslav Georgiev's talk at EuroPython 2018. It covers essential concepts such as service layers, the Django Rest Framework, and effective testing strategies, making it suitable for developers at all levels.

Step 1: Establish a Service Layer

• Understand the Role of Business Logic: Determine where your business logic should reside to keep your models and views clean.
• Define Services: Create service classes to encapsulate business logic. Services should:
  • Handle complex operations.
  • Interact with models.
  • Be reusable throughout your application.

Example of a Service Class

class UserService:
    def create_user(self, data):
        user = User(**data)
        user.save()
        return user

Step 2: Optimize Models and Views

• Avoid Fat Models and Views: Keep them lean by delegating business logic to service layers.
• Use Selectors: Implement selector classes for data retrieval. Selectors should:
  • Query models for specific use cases.
  • Simplify data access without cluttering views.

Example of a Selector Class

class UserSelector:
    @staticmethod
    def get_active_users():
        return User.objects.filter(is_active=True)

Step 3: Structure Your Django Project

• Organize Your Apps: Break your project into manageable apps based on functionality.
• Common Modules and Utilities: Create shared modules for utility functions to avoid duplication.

Step 4: Implementing APIs with Django Rest Framework

• Separate APIs into Two Groups:
  • Giving Data: Use generic views for straightforward data retrieval.
  • Taking Data: Use APIView combined with services for complex operations.

Example of Using Generics

class UserListView(generics.ListAPIView):
    queryset = User.objects.all()
    serializer_class = UserSerializer

Step 5: Error Handling and Serializers

• Error Management: Introduce consistent error handling across services.
• Inline Serializers: Utilize inline serializers to avoid the complexity of serializer reuse.

Example of Error Formatting

def format_error(message):
    return {'error': message, 'status': 400}

Step 6: Testing Strategies

• What to Test: Focus on testing critical components, such as:
  • Service methods.
  • API endpoints.
• Avoid Redundant Tests: Ensure tests are covering unique cases without duplicating efforts.

Example of a Simple Test

def test_create_user(self):
    response = self.client.post('/users/', {'name': 'John'})
    self.assertEqual(response.status_code, 201)

Conclusion

By following these structured steps, you can build a Django application that is both scalable and maintainable. Focus on establishing a clear service layer, organizing your project effectively, and implementing robust testing strategies. As a next step, consider applying these principles to a new or existing Django project to enhance its structure and longevity.