Added model for rescheduling & more tests

Author: adamspd

appointment/models.py

@@ -16,6 +16,7 @@
 from django.core.validators import MaxLengthValidator, MinLengthValidator, MinValueValidator
 from django.db import models
 from django.urls import reverse
+from django.utils import timezone
 from django.utils.translation import gettext_lazy as _
 from phonenumber_field.modelfields import PhoneNumberField
 
@@ -70,6 +71,14 @@ class Service(models.Model):
     image = models.ImageField(upload_to='services/', blank=True, null=True)
     currency = models.CharField(max_length=3, default='USD', validators=[MaxLengthValidator(3), MinLengthValidator(3)])
     background_color = models.CharField(max_length=50, null=True, blank=True, default="")
+    reschedule_limit = models.PositiveIntegerField(
+        default=0,
+        help_text=_("Maximum number of times an appointment can be rescheduled.")
+    )
+    allow_rescheduling = models.BooleanField(
+        default=False,
+        help_text=_("Indicates whether appointments for this service can be rescheduled.")
+    )
 
     # meta data
     created_at = models.DateTimeField(auto_now_add=True)
@@ -88,6 +97,8 @@ def save(self, *args, **kwargs):
         # price shouldn't be negative
         if self.price < 0:
             raise ValidationError(_("Price cannot be negative"))
+        if self.down_payment < 0:
+            raise ValidationError(_("Down payment cannot be negative"))
         if self.background_color == "":
             self.background_color = generate_rgb_color()
         return super().save(*args, **kwargs)
@@ -287,6 +298,7 @@ class AppointmentRequest(models.Model):
     staff_member = models.ForeignKey(StaffMember, on_delete=models.SET_NULL, null=True)
     payment_type = models.CharField(max_length=4, choices=PAYMENT_TYPES, default='full')
     id_request = models.CharField(max_length=100, blank=True, null=True)
+    reschedule_attempts = models.PositiveIntegerField(default=0)
 
     # meta data
     created_at = models.DateTimeField(auto_now_add=True)
@@ -301,7 +313,6 @@ def clean(self):
                 raise ValueError(_("Start time must be before end time"))
             if self.start_time == self.end_time:
                 raise ValueError(_("Start time and end time cannot be the same"))
-
         # Check for valid date
         try:
             # This will raise a ValueError if the date is not valid
@@ -359,6 +370,76 @@ def is_a_paid_service(self):
     def accepts_down_payment(self):
         return self.service.accepts_down_payment()
 
+    def can_be_rescheduled(self):
+        return self.reschedule_attempts < self.service.reschedule_limit
+
+    def increment_reschedule_attempts(self):
+        self.reschedule_attempts += 1
+        self.save(update_fields=['reschedule_attempts'])
+
+    def get_reschedule_history(self):
+        return self.reschedule_histories.all().order_by('-created_at')
+
+
+class AppointmentRescheduleHistory(models.Model):
+    appointment_request = models.ForeignKey(
+        'AppointmentRequest',
+        on_delete=models.CASCADE, related_name='reschedule_histories'
+    )
+    date = models.DateField(help_text=_("The previous date of the appointment before it was rescheduled."))
+    start_time = models.TimeField(
+        help_text=_("The previous start time of the appointment before it was rescheduled.")
+    )
+    end_time = models.TimeField(
+        help_text=_("The previous end time of the appointment before it was rescheduled.")
+    )
+    staff_member = models.ForeignKey(
+        StaffMember, on_delete=models.SET_NULL, null=True,
+        help_text=_("The previous staff member of the appointment before it was rescheduled.")
+    )
+    reason_for_rescheduling = models.TextField(
+        blank=True, null=True,
+        help_text=_("Reason for the appointment reschedule.")
+    )
+    reschedule_status = models.CharField(
+        max_length=10,
+        choices=[('pending', 'Pending'), ('confirmed', 'Confirmed')],
+        default='pending',
+        help_text=_("Indicates the status of the reschedule action.")
+    )
+    id_request = models.CharField(max_length=100, blank=True, null=True)
+
+    # meta data
+    created_at = models.DateTimeField(auto_now_add=True, help_text=_("The date and time the reschedule was recorded."))
+    updated_at = models.DateTimeField(auto_now=True, help_text=_("The date and time the reschedule was confirmed."))
+
+    class Meta:
+        verbose_name = _("Appointment Reschedule History")
+        verbose_name_plural = _("Appointment Reschedule Histories")
+        ordering = ['-created_at']
+
+    def __str__(self):
+        return f"Reschedule history for {self.appointment_request} from {self.date}"
+
+    def save(self, *args, **kwargs):
+        # if no id_request is provided, generate one
+        if self.id_request is None:
+            self.id_request = f"{get_timestamp()}{generate_random_id()}"
+        # date should not be in the past
+        if self.date < datetime.date.today():
+            raise ValidationError(_("Date cannot be in the past"))
+        try:
+            datetime.datetime.strptime(str(self.date), '%Y-%m-%d')
+        except ValueError:
+            raise ValidationError(_("The date is not valid"))
+        return super().save(*args, **kwargs)
+
+    def still_valid(self):
+        # if more than 5 minutes have passed, it is no longer valid
+        now = timezone.now()  # This is offset-aware to match self.created_at
+        delta = now - self.created_at
+        return delta.total_seconds() < 300
+
 
 class Appointment(models.Model):
     """
@@ -578,8 +659,19 @@ class Config(models.Model):
         default="",
         help_text=_("Name of your website."),
     )
-    app_offered_by_label = models.CharField(max_length=255, default=_("Offered by"),
-                                            help_text=_("Label for `Offered by` on the appointment page"))
+    app_offered_by_label = models.CharField(
+        max_length=255,
+        default=_("Offered by"),
+        help_text=_("Label for `Offered by` on the appointment page")
+    )
+    default_reschedule_limit = models.PositiveIntegerField(
+        default=3,
+        help_text=_("Default maximum number of times an appointment can be rescheduled across all services.")
+    )
+    allow_staff_change_on_reschedule = models.BooleanField(
+        default=True,
+        help_text=_("Allows clients to change the staff member when rescheduling an appointment.")
+    )
 
     # meta data
     created_at = models.DateTimeField(auto_now_add=True)

appointment/tests/models/test_appointment_reschedule_history.py

@@ -0,0 +1,64 @@
+from datetime import timedelta
+
+from django.core.exceptions import ValidationError
+from django.utils import timezone
+
+from appointment.models import AppointmentRescheduleHistory
+from appointment.tests.base.base_test import BaseTest
+
+
+class AppointmentRescheduleHistoryTestCase(BaseTest):
+    def setUp(self):
+        super().setUp()
+        self.appointment_request = self.create_appt_request_for_sm1()
+
+    def test_successful_creation(self):
+        reschedule_history = AppointmentRescheduleHistory.objects.create(
+            appointment_request=self.appointment_request,
+            date=timezone.now().date() + timedelta(days=1),  # Future date
+            start_time=timezone.now().time(),
+            end_time=(timezone.now() + timedelta(hours=1)).time(),
+            staff_member=self.staff_member1,
+            reason_for_rescheduling="Client request",
+            reschedule_status='pending'
+        )
+        self.assertIsNotNone(reschedule_history.id_request)  # Auto-generated id_request
+        self.assertTrue(reschedule_history.still_valid())
+
+    def test_date_in_past_validation(self):
+        with self.assertRaises(ValidationError):
+            AppointmentRescheduleHistory.objects.create(
+                appointment_request=self.appointment_request,
+                date=timezone.now().date() - timedelta(days=1),  # Past date
+                start_time=timezone.now().time(),
+                end_time=(timezone.now() + timedelta(hours=1)).time(),
+                staff_member=self.staff_member1
+            )
+
+    def test_invalid_date_validation(self):
+        with self.assertRaises(TypeError):
+            AppointmentRescheduleHistory.objects.create(
+                appointment_request=self.appointment_request,
+                date="invalid-date",  # Invalid date format
+                start_time=timezone.now().time(),
+                end_time=(timezone.now() + timedelta(hours=1)).time(),
+                staff_member=self.staff_member1
+            )
+
+    def test_still_valid(self):
+        reschedule_history = AppointmentRescheduleHistory.objects.create(
+            appointment_request=self.appointment_request,
+            date=timezone.now().date() + timedelta(days=1),
+            start_time=timezone.now().time(),
+            end_time=(timezone.now() + timedelta(hours=1)).time(),
+            staff_member=self.staff_member1,
+            reason_for_rescheduling="Client request",
+            reschedule_status='pending'
+        )
+        # Directly test the still_valid method
+        self.assertTrue(reschedule_history.still_valid())
+
+        # Simulate passages of time beyond the validity window
+        reschedule_history.created_at -= timedelta(minutes=6)
+        reschedule_history.save()
+        self.assertFalse(reschedule_history.still_valid())

appointment/tests/models/test_model_appointment.py

@@ -2,9 +2,11 @@
 
 from django.core.exceptions import ValidationError
 from django.db import IntegrityError
+from django.utils import timezone
 
-from appointment.models import Appointment
+from appointment.models import Appointment, DayOff, WorkingHours
 from appointment.tests.base.base_test import BaseTest
+from appointment.utils.date_time import get_weekday_num
 
 
 class AppointmentModelTestCase(BaseTest):
@@ -220,3 +222,48 @@ def test_get_staff_member_name_without_staff_member(self):
         self.appointment.appointment_request.staff_member = None
         self.appointment.appointment_request.save()
         self.assertEqual(self.appointment.get_staff_member_name(), "")
+
+    def test_get_service_img_url_no_image(self):
+        """Service should handle cases where no image is provided gracefully."""
+        self.assertEqual(self.appointment.get_service_img_url(), "")
+
+
+class AppointmentValidDateTestCase(BaseTest):
+    def setUp(self):
+        super().setUp()
+        self.weekday = "Monday"  # Example weekday
+        self.weekday_num = get_weekday_num(self.weekday)
+        WorkingHours.objects.create(staff_member=self.staff_member1, day_of_week=self.weekday_num,
+                                    start_time=time(9, 0),
+                                    end_time=time(17, 0))
+        self.appt_date = timezone.now().date() + timedelta(days=(self.weekday_num - timezone.now().weekday()) % 7)
+        self.start_time = timezone.now().replace(hour=10, minute=0, second=0, microsecond=0)
+        self.current_appointment_id = None
+
+    def test_staff_member_works_on_given_day(self):
+        is_valid, message = Appointment.is_valid_date(self.appt_date, self.start_time, self.staff_member1,
+                                                      self.current_appointment_id, self.weekday)
+        self.assertTrue(is_valid)
+
+    def test_staff_member_does_not_work_on_given_day(self):
+        non_working_day = "Sunday"
+        non_working_day_num = get_weekday_num(non_working_day)
+        appt_date = self.appt_date + timedelta(days=(non_working_day_num - self.weekday_num) % 7)
+        is_valid, message = Appointment.is_valid_date(appt_date, self.start_time, self.staff_member1,
+                                                      self.current_appointment_id, non_working_day)
+        self.assertFalse(is_valid)
+        self.assertIn("does not work on this day", message)
+
+    def test_start_time_outside_working_hours(self):
+        early_start_time = timezone.now().replace(hour=8, minute=0)  # Before working hours
+        is_valid, message = Appointment.is_valid_date(self.appt_date, early_start_time, self.staff_member1,
+                                                      self.current_appointment_id, self.weekday)
+        self.assertFalse(is_valid)
+        self.assertIn("outside of", message)
+
+    def test_staff_member_has_day_off(self):
+        DayOff.objects.create(staff_member=self.staff_member1, start_date=self.appt_date, end_date=self.appt_date)
+        is_valid, message = Appointment.is_valid_date(self.appt_date, self.start_time, self.staff_member1,
+                                                      self.current_appointment_id, self.weekday)
+        self.assertFalse(is_valid)
+        self.assertIn("has a day off on this date", message)

appointment/tests/models/test_model_appointment_request.py

@@ -1,3 +1,4 @@
+import datetime
 from datetime import date, time, timedelta
 
 from django.core.exceptions import ValidationError
@@ -9,6 +10,7 @@ class AppointmentRequestModelTestCase(BaseTest):
     def setUp(self):
         super().setUp()
         self.ar = self.create_appointment_request_(self.service1, self.staff_member1)
+        self.today = date.today()
 
     def test_appointment_request_creation(self):
         """Test if an appointment request can be created."""
@@ -115,3 +117,53 @@ def test_appointment_duration_exceeds_service_time(self):
         with self.assertRaises(ValidationError):
             self.create_appointment_request_(self.service1, self.staff_member1, start_time=time(9, 0),
                                              end_time=time(13, 0))
+
+    def test_reschedule_attempts_limit(self):
+        """Test appointment request's ability to be rescheduled based on service's limit."""
+        self.service1.reschedule_limit = 2
+        self.service1.save()
+
+        # Simulate rescheduling attempts
+        self.ar.increment_reschedule_attempts()
+        self.assertTrue(self.ar.can_be_rescheduled())
+
+        self.ar.increment_reschedule_attempts()
+        self.assertFalse(self.ar.can_be_rescheduled(),
+                         "Should not be reschedulable after reaching the limit")
+
+    def test_appointment_request_with_invalid_date(self):
+        """Appointment date should be valid and not in the past."""
+        invalid_date = self.today - timedelta(days=1)
+        with self.assertRaises(ValidationError, msg="Date cannot be in the past"):
+            self.create_appointment_request_(
+                self.service1, self.staff_member1, date_=invalid_date, start_time=time(10, 0), end_time=time(11, 0)
+            )
+        with self.assertRaises(ValidationError, msg="The date is not valid"):
+            date_ = datetime.datetime.strptime("31-03-2021", "%d-%m-%Y").date()
+            self.create_appointment_request_(
+                self.service1, self.staff_member1, date_=date_,
+                start_time=time(10, 0), end_time=time(11, 0)
+            )
+
+    def test_start_time_after_end_time(self):
+        """Start time should not be after end time."""
+        with self.assertRaises(ValueError, msg="Start time must be before end time"):
+            self.create_appointment_request_(
+                self.service1, self.staff_member1, date_=self.today, start_time=time(11, 0), end_time=time(10, 0)
+            )
+
+    def test_start_time_equals_end_time(self):
+        """Start time and end time should not be the same."""
+        with self.assertRaises(ValidationError, msg="Start time and end time cannot be the same"):
+            self.create_appointment_request_(
+                self.service1, self.staff_member1, date_=self.today, start_time=time(10, 0), end_time=time(10, 0)
+            )
+
+    def test_appointment_duration_not_exceed_service(self):
+        """Appointment duration should not exceed the service's duration."""
+        extended_end_time = time(11, 30)  # 2.5 hours, exceeding the 1-hour service duration
+        with self.assertRaises(ValidationError, msg="Duration cannot exceed the service duration"):
+            self.create_appointment_request_(
+                self.service1, self.staff_member1, date_=self.today, start_time=time(9, 0), end_time=extended_end_time
+            )
+

appointment/tests/models/test_model_config.py

@@ -77,3 +77,8 @@ def test_update_website_name(self):
 
         updated_config = Config.objects.get(pk=self.config.pk)
         self.assertEqual(updated_config.website_name, new_name)
+
+    def test_cant_delete_config(self):
+        """Test that a configuration cannot be deleted."""
+        self.config.delete()
+        self.assertIsNotNone(Config.objects.first())