medicar.py

# backend/api/models.py

from django.db import models
from phone_field import PhoneField
from django.contrib.auth import get_user_model
from datetime import date
# from rest_framework.exceptions import ValidationError

"""
A model is the single, definitive source of information about your data.
It contains the essential fields and behaviors of the data you’re storing.
Generally, each model maps to a single database table.
"""


class Specialty(models.Model):
    """
    This class contains the representation of the fields in the Specialty table.
    """
    name = models.CharField(max_length=80)

    class Meta:
        verbose_name = 'Specialty'
        verbose_name_plural = 'Specialties'

    def __str__(self):
        """A string representation of the model."""
        return f'{self.id}, {self.name}'


class Doctor(models.Model):
    """
    This class contains the representation of the fields in the Doctor table.
    """
    name = models.CharField(max_length=150)
    crm = models.IntegerField(unique=True)
    email = models.EmailField(max_length=150, blank=True, null=True)
    phone = PhoneField(
        blank=True, max_length=12,
        help_text="Phone number must be in the format: '(DDD) 9XXXX-XXXX'. Only numbers")
    specialty = models.ForeignKey('api.Specialty', on_delete=models.PROTECT)

    class Meta:
        verbose_name = 'Doctor'
        verbose_name_plural = 'Doctors'

    def __str__(self):
        """A string representation of the model."""
        return f'{self.id}, {self.crm}, {self.name}, {self.specialty}'


class Hourly(models.Model):
    """
    This class contains the representation of the field in the Hourly table.
    """
    hour = models.TimeField(null=False)

    class Meta:
        verbose_name = 'Hourly'
        verbose_name_plural = 'Hourlys'

    def __str__(self):
        """A string representation of the model."""
        return f'{self.hour}'


class Schedule(models.Model):
    """
    This class contains the representation of the fields in the Schedule table.
    """
    doctor = models.ForeignKey('Doctor', on_delete=models.PROTECT)
    day = models.DateField(default=date.today, null=False)
    hourlys = models.ManyToManyField(Hourly)

    class Meta:
        verbose_name = 'Schedule'
        verbose_name_plural = 'Schedules'
        ordering = ['-day']
        unique_together = ('doctor', 'day')

    def __str__(self):
        """A string representation of the model."""
        return f'{self.doctor.name}, {self.day}'


class MedicalAppointment(models.Model):
    """
    This class contains the representation of the fields in the MedicalAppointment table.
    """
    day = models.DateTimeField()
    hourly = models.ForeignKey('api.Hourly', on_delete=models.DO_NOTHING)
    scheduling_date = models.DateTimeField(auto_now=True)
    schedule = models.ForeignKey('api.Schedule', related_name='schedule_hourlys', on_delete=models.PROTECT)
    user = models.ForeignKey(get_user_model(), on_delete=models.CASCADE, blank=True, null=True)

    def save(self, *args, **kwargs):
        if self.day is None:
            schedule = Schedule.objects.get(pk=self.schedule.id)
            self.day = schedule.day.strftime(f'%Y-%m-%d {self.hourly}')
        super(MedicalAppointment, self).save(*args, **kwargs)

    def __str__(self):
        return f'{self.schedule.doctor.name},{self.hourly}'

        
        
   =========================================================================================================
   
   # backend/api/views.py
   
   from datetime import datetime

from backend.api.models import Specialty, Doctor, Schedule, MedicalAppointment
from backend.api.serializers import SpecialtySerializer, DoctorSerializer, ScheduleSerializer, MedicalAppointmentSerializer

from rest_framework.viewsets import ReadOnlyModelViewSet
from rest_framework.filters import OrderingFilter, SearchFilter
from rest_framework import status
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response
from rest_framework.viewsets import ModelViewSet, ReadOnlyModelViewSet


class SpecialtyViewSet(ReadOnlyModelViewSet):
    serializer_class = SpecialtySerializer
    queryset = Specialty.objects.all()
    search_fields = ('name',)
    filter_backends = (SearchFilter, OrderingFilter)
    permission_classes = (IsAuthenticated,)


class DoctorViewSet(ReadOnlyModelViewSet):
    serializer_class = DoctorSerializer
    queryset = Doctor.objects.all()
    search_fields = ('name',)
    filter_backends = (SearchFilter, OrderingFilter)
    permission_classes = (IsAuthenticated,)

    def get_queryset(self):
        queryset = self.queryset

        specialty = self.request.query_params.getlist('specialty')
        if specialty:
            return queryset.filter(specialty__id__in=specialty)
        return queryset


class ScheduleViewSet(ReadOnlyModelViewSet):
    queryset = Schedule.objects.all()
    serializer_class = ScheduleSerializer
    filter_backends = (SearchFilter, OrderingFilter)
    permission_classes = (IsAuthenticated,)

    def get_queryset(self):
        queryset = self.queryset
        today = datetime.now()

        doctors = self.request.query_params.getlist('doctor')
        if doctors:
            queryset = queryset.filter(doctor__id__in=doctors)

        especialties = self.request.query_params.getlist('especialty')
        if especialties:
            queryset = queryset.filter(doctor__especialty__id__in=especialties)

        start_date = self.request.query_params.get('start_date')
        final_date = self.request.query_params.get('data_final')
        if start_date and final_date:
            queryset = queryset.filter(day__range=(start_date, final_date))
        else:
            queryset = queryset.filter(day__gte=today.strftime('%Y-%m-%d'))

        queryset = queryset.order_by('day')

        return queryset


class MedicalAppointmentViewSet(ModelViewSet):
    queryset = MedicalAppointment.objects.all()
    serializer_class = MedicalAppointmentSerializer
    filter_backends = (OrderingFilter,)
    allowed_methods = ('GET', 'POST', 'DELETE')
    permission_classes = (IsAuthenticated,)

    def get_queryset(self):
        return MedicalAppointment.objects.filter(user=self.request.user)

    def create(self, request, *args, **kwargs):
        appointment = MedicalAppointment.objects.get(agenda_id=request.data.get(
            'schedule_id'), hourly=request.data.get('hourly'))
        appointment.user = self.request.user
        appointment.save(*args, **kwargs)
        serializer = MedicalAppointmentSerializer(appointment)
        return Response(serializer.data, status=status.HTTP_201_CREATED)

    def destroy(self, request, *args, **kwargs):
        now = datetime.now().strftime('%Y-%m-%d %H:%M')
        appointment = MedicalAppointment.objects.filter(pk=self.kwargs.get(
            'pk'), user=self.request.user, day__gte=now).first()
        if appointment is None:
            return Response(status=status.HTTP_404_NOT_FOUND)
        appointment.user = None
        appointment.save()
        return Response(status=status.HTTP_204_NO_CONTENT)
        
===============================================================================================================

# backend/ap/serializers.py

from datetime import datetime
from rest_framework import serializers

from backend.api.models import Specialty, Doctor, Schedule, MedicalAppointment


class SpecialtySerializer(serializers.ModelSerializer):
    class Meta:
        model = Specialty
        fields = ('id', 'name')


class DoctorSerializer(serializers.ModelSerializer):
    specialty = SpecialtySerializer(read_only=True)

    class Meta:
        model = Doctor
        fields = ('id', 'crm', 'name', 'specialty')


class HourlyList(serializers.ListSerializer):
    def to_representation(self, data):
        now = datetime.now().strftime('14:30:00')
        return data.queryset.filter(hourly__gte=now)


class HourlySerializer(serializers.ModelSerializer):
    hourly = serializers.TimeField(format='%H:%M')

    class Meta:
        model = MedicalAppointment
        fields = ('hourly',)


class ScheduleSerializer(serializers.ModelSerializer):
    doctor = DoctorSerializer(read_only=True)
    hourlys = serializers.SerializerMethodField('get_hourlys')

    def get_hourlys(self, schedule):

        now = datetime.now().strftime('%Y-%m-%d %H:%M')
        queryset = MedicalAppointment.objects.filter(schedule__id=schedule.id, day__gte=now, user__isnull=True)
        serializer = HourlySerializer(instance=queryset, many=True)
        data = [hourly.get('hourly') for hourly in serializer.data]
        return data

    class Meta:
        model = Schedule
        fields = ('id', 'doctor', 'day', 'hourlys')


class MedicalAppointmentSerializer(serializers.ModelSerializer):
    doctor = serializers.SerializerMethodField('get_doctor')

    def get_doctor(self, appointment):
        queryset = Doctor.objects.get(pk=appointment.schedule.doctor.id)
        return DoctorSerializer(instance=queryset).data

    class Meta:
        model = MedicalAppointment
        fields = ('id', 'day', 'hourly', 'scheduling_date', 'doctor')


===========================================================================================

# backend/api/admin.py

from django.contrib import admin

from backend.api import models


@admin.register(models.Specialty)
class SpecialtyAdmin(admin.ModelAdmin):
    list_display = ('name',)
    list_filter = ('name',)


@admin.register(models.Doctor)
class DoctorAdmin(admin.ModelAdmin):
    list_display = ('name', 'crm')
    list_filter = ('name', 'crm')


@admin.register(models.Hourly)
class HourlyAdmin(admin.ModelAdmin):
    list_display = ('hour',)
    list_filter = ('hour',)


class MedicalAppointmentInline(admin.TabularInline):
    model = models.MedicalAppointment
    exclude = ('user', 'day')


@admin.register(models.Schedule)
class ScheduleAdmin(admin.ModelAdmin):
    fields = (('day', 'doctor'),)
    list_filter = ('day', 'doctor')
    inlines = (MedicalAppointmentInline,)