03 Rest Monitoring

Para criar um Django REST API com base nas classes que definimos no diagrama, você pode seguir os passos abaixo. Vamos estruturar o app com as classes principais de Usuário, Atividade, Tipo de Atividade, Métrica de Atividade e Histórico de Atividades.

1. Configuração Inicial do Projeto Django

Certifique-se de ter o Django e o Django REST Framework instalados. Se ainda não estiverem instalados, execute:

pip install django djangorestframework

Criação do Projeto e App

django-admin startproject sports_monitoring
cd sports_monitoring
python manage.py startapp activities

2. Configurar o Projeto Django

No arquivo settings.py do projeto, adicione o rest_framework e o novo app activities na lista de aplicativos instalados:

INSTALLED_APPS = [
    # Apps Django
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',

    # Django REST Framework
    'rest_framework',

    # App de atividades
    'activities',
]

3. Modelagem das Classes no App Django

No arquivo activities/models.py, você irá definir as classes baseadas no diagrama que criamos.

from django.db import models
from django.contrib.auth.models import User  # Reutilizando o modelo de User do Django

class ActivityType(models.Model):
    name = models.CharField(max_length=50)
    description = models.TextField(blank=True, null=True)

    def __str__(self):
        return self.name

class Activity(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE, related_name="activities")
    activity_type = models.ForeignKey(ActivityType, on_delete=models.CASCADE)
    start_time = models.DateTimeField()
    end_time = models.DateTimeField()
    location = models.CharField(max_length=255, blank=True, null=True)
    description = models.TextField(blank=True, null=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    def __str__(self):
        return f'{self.activity_type.name} by {self.user.username}'

class ActivityMetrics(models.Model):
    activity = models.OneToOneField(Activity, on_delete=models.CASCADE, related_name="metrics")
    distance_km = models.FloatField()
    duration_minutes = models.FloatField()
    avg_speed_kmh = models.FloatField()
    calories_burned = models.FloatField()
    elevation_gain = models.FloatField(blank=True, null=True)

    def __str__(self):
        return f'Metrics for {self.activity}'

class ActivityHistory(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    activity = models.ForeignKey(Activity, on_delete=models.CASCADE)
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return f'History for {self.user.username}'

4. Criar as Migrations e Migrar o Banco de Dados

Agora que o modelo está pronto, criamos as migrações e aplicamos ao banco de dados:

python manage.py makemigrations
python manage.py migrate

5. Serializers para a API

Crie os serializers para converter as instâncias dos modelos em JSON no arquivo activities/serializers.py.

from rest_framework import serializers
from django.contrib.auth.models import User
from .models import Activity, ActivityType, ActivityMetrics, ActivityHistory

class UserSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ['id', 'username', 'email']

class ActivityTypeSerializer(serializers.ModelSerializer):
    class Meta:
        model = ActivityType
        fields = ['id', 'name', 'description']

class ActivityMetricsSerializer(serializers.ModelSerializer):
    class Meta:
        model = ActivityMetrics
        fields = ['distance_km', 'duration_minutes', 'avg_speed_kmh', 'calories_burned', 'elevation_gain']

class ActivitySerializer(serializers.ModelSerializer):
    metrics = ActivityMetricsSerializer()
    class Meta:
        model = Activity
        fields = ['id', 'activity_type', 'start_time', 'end_time', 'location', 'description', 'metrics']

class ActivityHistorySerializer(serializers.ModelSerializer):
    activity = ActivitySerializer()
    user = UserSerializer()

    class Meta:
        model = ActivityHistory
        fields = ['id', 'user', 'activity', 'created_at']

6. Views para a API

Agora, crie as views para expor as APIs no arquivo activities/views.py.

from rest_framework import viewsets
from .models import Activity, ActivityType, ActivityMetrics, ActivityHistory
from .serializers import ActivitySerializer, ActivityTypeSerializer, ActivityMetricsSerializer, ActivityHistorySerializer

class ActivityTypeViewSet(viewsets.ModelViewSet):
    queryset = ActivityType.objects.all()
    serializer_class = ActivityTypeSerializer

class ActivityViewSet(viewsets.ModelViewSet):
    queryset = Activity.objects.all()
    serializer_class = ActivitySerializer

class ActivityMetricsViewSet(viewsets.ModelViewSet):
    queryset = ActivityMetrics.objects.all()
    serializer_class = ActivityMetricsSerializer

class ActivityHistoryViewSet(viewsets.ModelViewSet):
    queryset = ActivityHistory.objects.all()
    serializer_class = ActivityHistorySerializer

7. URLs

No arquivo activities/urls.py, defina as rotas para as views:

from django.urls import include, path
from rest_framework.routers import DefaultRouter
from . import views

router = DefaultRouter()
router.register(r'activity-types', views.ActivityTypeViewSet)
router.register(r'activities', views.ActivityViewSet)
router.register(r'metrics', views.ActivityMetricsViewSet)
router.register(r'history', views.ActivityHistoryViewSet)

urlpatterns = [
    path('', include(router.urls)),
]

Em seguida, inclua as URLs do app activities no arquivo sports_monitoring/urls.py:

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include('activities.urls')),
]

8. Testando a API

Agora, você pode iniciar o servidor do Django:

python manage.py runserver

Acesse http://127.0.0.1:8000/api/ para ver os endpoints disponíveis para criar e visualizar atividades, tipos de atividades, métricas e histórico.

Conclusão

Com essa estrutura, você já terá uma API RESTful funcionando, permitindo que usuários criem e visualizem suas atividades esportivas e suas métricas. Essa implementação pode ser expandida com autenticação (por exemplo, com TokenAuthentication ou JWT) e outras funcionalidades como filtros ou paginação, dependendo das necessidades do projeto.