huge updates

app/signals.py

@@ -0,0 +1,111 @@
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+from django.core.cache import cache
+from datetime import date, timedelta
+from .models import CourseTracking, Student
+from django.db import transaction
+
+@receiver(post_save, sender=CourseTracking)
+def update_completion_percentage(sender, instance, **kwargs):
+    """
+    Signal to update completion percentage after save
+    Also caches the percentage for 1 hour to avoid frequent recalculations
+    """
+    cache_key = f"course_tracking_percentage_{instance.id}"
+    cache.set(cache_key, instance.completion_percentage, 3600)  # Cache for 1 hour
+
+
+@receiver(post_save, sender=Student)
+def create_course_tracking(sender, instance, created, **kwargs):
+    """
+    Signal handler to create CourseTracking when a new student is created
+    or when a course is assigned to an existing student
+    """
+    print(f"Signal triggered for student: {instance.name}")
+    print(f"Created: {created}")
+    print(f"Course: {instance.course}")
+    print(f"Current Semester: {instance.current_semester}")
+
+    # Check if student has a course assigned
+    if instance.course:
+        try:
+            # Check if course tracking already exists
+            existing_tracking = CourseTracking.objects.filter(
+                student=instance, course=instance.course
+            ).first()
+
+            if existing_tracking:
+                print(f"Course tracking already exists for {instance.name}")
+                return
+
+            # Calculate dates based on course duration
+            start_date = instance.joining_date or date.today()
+
+            # Calculate expected end date based on course duration type
+            if instance.course.duration_type == "Year":
+                # For year-based courses, each year is 365 days
+                years = instance.course.duration
+                duration_days = years * 365
+            else:  # Semester based
+                # For semester-based courses:
+                # - Each year has 2 semesters
+                # - Total years is the same as course duration
+                years = instance.course.duration
+                duration_days = years * 365  # Use full years for total duration
+
+            expected_end_date = start_date + timedelta(days=duration_days)
+
+            # Create course tracking with transaction
+            with transaction.atomic():
+                course_tracking = CourseTracking.objects.create(
+                    student=instance,
+                    course=instance.course,
+                    start_date=start_date,
+                    expected_end_date=expected_end_date,
+                    current_semester=instance.current_semester,
+                    semester_start_date=start_date,
+                    semester_end_date=start_date
+                    + timedelta(days=180),  # 6 months for first semester
+                )
+
+                # Force initial percentage calculation
+                course_tracking.force_update_percentage()
+
+                print(
+                    f"Successfully created course tracking for student {instance.name}"
+                )
+                print(f"Start Date: {start_date}")
+                print(f"Expected End Date: {expected_end_date}")
+                print(f"Current Semester: {instance.current_semester}")
+
+        except Exception as e:
+            print(
+                f"Error creating course tracking for student {instance.name}: {str(e)}"
+            )
+            # Log the error but don't prevent student creation
+            # You might want to add proper logging here instead of print statements
+    else:
+        print(f"No course assigned to student {instance.name}")
+
+
+@receiver(post_save, sender=Student)
+def sync_student_semester(sender, instance, created, **kwargs):
+    """Signal handler to sync student's current_semester with course tracking"""
+    if instance.course:
+        try:
+            course_tracking = CourseTracking.objects.get(
+                student=instance, course=instance.course
+            )
+            if course_tracking.current_semester != instance.current_semester:
+                course_tracking.current_semester = instance.current_semester
+                course_tracking.save()
+        except CourseTracking.DoesNotExist:
+            pass
+
+
+@receiver(post_save, sender=CourseTracking)
+def sync_course_tracking_semester(sender, instance, created, **kwargs):
+    """Signal handler to sync course tracking's current_semester with student"""
+    if instance.student.current_semester != instance.current_semester:
+        instance.student.current_semester = instance.current_semester
+        instance.student.save()