Backend: Implementando Eventos Favoritos (User-Event M2M)

Hey guys! Let's dive into how we can implement a fantastic feature in our backend: allowing users to mark events as favorites. This is super useful for quick access to events a user is interested in. We'll be using a User-Event Many-to-Many (M2M) relationship to make this happen. This guide will cover everything from the model design to API endpoints, serializer modifications, and even testing. We'll break down the tasks, acceptance criteria, and even touch upon the UX considerations. Get ready to build a rock-solid feature that enhances user engagement. Let's get started!

Descripción General de la Implementación

Our main goal is to enable users to save their favorite events for quick and easy access. This will involve creating a UserFavoriteEvent model to manage the relationship between users and events, updating our API endpoints to handle favoriting and unfavoriting actions, and modifying the EventSerializer to indicate whether an event is favorited by the current user. Finally, we'll create endpoints to retrieve a user's favorite events. We are focusing on building a user-friendly and efficient system. This will not only improve user experience but also provide a solid foundation for future features.

Modelo de Datos: UserFavoriteEvent

First, let's create the foundation of our feature: the UserFavoriteEvent model. This model will be the core of our M2M relationship, linking users to their favorite events. It will store information about which users have favorited which events, and when they did so. Here’s the breakdown:

class UserFavoriteEvent(models.Model):
    """Eventos favoritos del usuario."""
    user = models.ForeignKey(
        User,
        on_delete=models.CASCADE,
        related_name='favorite_events'
    )
    event = models.ForeignKey(
        'events.Event',
        on_delete=models.CASCADE,
        related_name='favorited_by'
    )
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        unique_together = ['user', 'event']
        ordering = ['-created_at']

• user: This is a ForeignKey to the User model. It defines the user who has favorited the event. The related_name='favorite_events' allows us to easily access a user's favorite events through user.favorite_events. This creates a seamless connection between users and their favorite events.
• event: This is a ForeignKey to the Event model. It defines the event that the user has favorited. The related_name='favorited_by' allows us to access the users who have favorited a specific event through event.favorited_by. This will be essential for showing which users have favorited an event.
• created_at: This DateTimeField automatically records the time when the favorite was created. The auto_now_add=True ensures that this field is automatically populated when a new UserFavoriteEvent is created. This will be invaluable for sorting and displaying the favorites.
• Meta: The unique_together ensures that a user can only favorite an event once. The ordering = ['-created_at'] orders the favorites by creation date, with the most recent favorites appearing first. This ensures data integrity and provides an organized way of accessing favorites.

This UserFavoriteEvent model acts as the intermediary, enabling the M2M relationship between users and events. It provides a robust structure for managing and retrieving favorite events.

API Endpoints: Interacting with Favorites

Next, let’s define the API endpoints that will allow users to interact with their favorite events. These endpoints will handle adding events to favorites, removing events from favorites, and retrieving lists of favorited events. Think of these as the gateways to our new feature.

# En EventViewSet
POST   /api/v1/events/{id}/favorite/      # Añadir a favoritos
DELETE /api/v1/events/{id}/favorite/      # Quitar de favoritos
GET    /api/v1/events/{id}/               # Incluir is_favorited en response

# Usuario
GET    /api/v1/users/me/favorites/        # Mis eventos favoritos
GET    /api/v1/users/me/favorites/upcoming/  # Favoritos próximos

• /api/v1/events/{id}/favorite/ (POST): This endpoint will be used to add an event to the user's favorites. The {id} represents the ID of the event. This is a crucial endpoint.
• /api/v1/events/{id}/favorite/ (DELETE): This endpoint will remove an event from the user's favorites. This ensures flexibility for the user.
• /api/v1/events/{id}/ (GET): This endpoint will return the event details, and it will include a boolean field is_favorited in the response, indicating whether the current user has favorited the event. This adds essential context to the event details.
• /api/v1/users/me/favorites/: This endpoint will return a list of the user's favorite events. This provides a convenient way to access a user’s favorited events.
• /api/v1/users/me/favorites/upcoming/: This endpoint will return a list of the user's upcoming favorite events. This can be implemented by filtering the favorite events by future dates. This is a user-friendly addition. These endpoints are designed to be intuitive.

Modificaciones al EventSerializer: Enhancing Event Details

To display whether an event is favorited, we need to modify the EventSerializer. This will add an is_favorited field to the event details, which will indicate whether the current user has favorited the event. This makes sure the UI is in sync.

class EventSerializer(serializers.ModelSerializer):
    is_favorited = serializers.SerializerMethodField()
    favorites_count = serializers.IntegerField(read_only=True)

    def get_is_favorited(self, obj):
        request = self.context.get('request')
        if request and request.user.is_authenticated:
            return obj.favorited_by.filter(user=request.user).exists()
        return False

• is_favorited: This SerializerMethodField will dynamically determine whether the event is favorited by the current user. This field is dynamic.
• favorites_count: This IntegerField will display the number of users who favorited this event, it's set to read-only, which means it will only display and not take any input. This will allow the front-end to easily display whether an event is favorited.
• get_is_favorited(self, obj): This method retrieves the request from the serializer context and checks if the user is authenticated. If the user is authenticated, it checks if the user has favorited the event using obj.favorited_by.filter(user=request.user).exists(). It returns True if the event is favorited and False otherwise. This ensures that the is_favorited field reflects the user's status accurately, providing an accurate representation.

This modification adds essential context to the event details, making the user experience much more intuitive and user-friendly.

Tareas Detalladas y Criterios de Aceptación

Now, let's break down the implementation into specific tasks. We'll also cover the acceptance criteria to ensure that our feature works as expected. This is how we'll get it done!

Tareas

• [ ] Añadir modelo a app events o crear relación en users: Decide where to place the UserFavoriteEvent model. Typically, it will be added in the events app, as it directly relates to events. This is the starting point.
• [ ] Crear migración: Create and apply the database migrations to create the tables for the UserFavoriteEvent model. This will create the necessary tables.
• [ ] Añadir actions favorite/unfavorite en EventViewSet: Implement the favorite and unfavorite actions in the EventViewSet to handle the POST and DELETE requests for favoriting and unfavoriting events. These actions will handle the logic.
• [ ] Modificar EventSerializer para incluir is_favorited: Implement the is_favorited field in the EventSerializer as described earlier. This enhances the event details.
• [ ] Crear endpoint de favoritos del usuario: Implement the endpoint to retrieve the user's favorite events. This will give the user a personalized list.
• [ ] Añadir annotate para optimizar queries: Optimize queries by using annotate to reduce database calls when retrieving event lists and checking if an event is favorited. This enhances efficiency.
• [ ] Escribir tests: Write unit tests to verify that the API endpoints and serializer work correctly. This ensures quality and reliability.

Criterios de Aceptación

• [ ] Usuario puede marcar/desmarcar favoritos: Users should be able to successfully add and remove events from their favorites list. This is the core functionality.
• [ ] is_favorited se muestra en detalle de evento: The is_favorited field should accurately reflect whether the current user has favorited the event. This adds critical context.
• [ ] Lista de favoritos ordenada por fecha: The user's list of favorite events should be ordered by the date they were added, with the most recent favorites appearing first. This ensures the list is intuitive.
• [ ] No se pueden duplicar favoritos: Users should not be able to add the same event to their favorites list multiple times. This prevents data inconsistencies.
• [ ] Solo usuarios autenticados pueden usar favoritos: Only authenticated users should be able to add or remove events from their favorites. This ensures security.

Optimización y Consideraciones Adicionales

Optimización de Consultas

To improve performance, especially with a large number of events, we need to optimize our database queries. We should use Django's annotate function to add the is_favorited field to event queries. This reduces the number of database calls. We can also add an index to the UserFavoriteEvent model on the user and event fields to speed up lookups.

Diseño de UX

When designing the user interface, consider the following:

• Clear Visual Indication: Provide a clear visual indication to the user that an event has been favorited (e.g., a filled-in heart icon).
• Easy Access to Favorites: Make the user's favorite events easily accessible from their profile or a dedicated section of the app.
• Feedback: Provide immediate feedback to the user when they favorite or unfavorite an event (e.g., a success message).

By following these steps, we can ensure our application is both functional and user-friendly.

Conclusión

Implementing the user favorite events feature will provide a more engaging and personalized experience for our users. By following these steps and focusing on the acceptance criteria, we can build a robust and valuable feature that enhances user engagement. Remember to write tests to ensure everything works correctly. Good luck, and happy coding, guys! We hope this detailed guide helps you through the process, providing a step-by-step approach to implementing a successful backend feature.