Merge branch 'main' into assignment_create

Author: Jose-Alarcon1

.github/workflows/django_ci_cd.yml

@@ -1,5 +1,5 @@
 name: Django CI/CD
-
+# Triggers when making a pull request to main and commits to main
 on:
   push:
     branches:
@@ -31,12 +31,6 @@ jobs:
           sudo service redis-server start
           sudo service redis-server status
 
-      - name: Install Flake8 and Run Linter
-        run: |
-          pip install flake8
-          flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
-          flake8 . --count --exit-zero --max-complexity=10 --max-line-length=88 --statistics
-
       - name: Install Dependencies
         run: |
           python -m pip install --upgrade pip
@@ -53,19 +47,16 @@ jobs:
           echo "CLOUDINARY_API_SECRET=${{ secrets.CLOUDINARY_API_SECRET }}" >> .env
         shell: bash
 
+      # Applying migrations
       - name: Run Migrations
         run: python manage.py migrate
 
-      - name: Run Tests with Coverage
-        run: |
-          coverage run manage.py test
-          coverage report
-          coverage html  # Generates the HTML report in 'htmlcov' directory
+      # Generate coverage XML report for Codecov
+      - name: Run tests and generate coverage XML report
+        run: pytest --cov --cov-branch --cov-report=xml
 
-      # Upload coverage HTML report as artifact
-      - name: Upload coverage HTML report
-        uses: actions/upload-artifact@v4
+      # Upload to Codecov (external visualization tool)
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v5
         with:
-          name: coverage-report-html
-          path: backend/htmlcov/  # Upload the entire 'htmlcov' directory
-
+            token: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/django_linter.yml

@@ -0,0 +1,31 @@
+name: Django Linter
+# Triggers when making a pull request to main and commits to main
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: backend  # Set the default working directory
+
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v3
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: 3.10.12
+
+      - name: Install Flake8 and Run Linter
+        run: |
+          pip install flake8
+          flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+          flake8 . --count --exit-zero --max-complexity=10 --max-line-length=88 --statistics

README.md

@@ -0,0 +1,25 @@
+[run]
+source =
+    apps/users
+    apps/lessons
+    apps/submissions
+    apps/uploads
+    apps/chat
+    apps/notifications
+    apps/pomodoro
+    apps/bookings
+    apps/planner
+    apps/search
+
+omit =
+    */tests/*
+    */migrations/*
+    */__init__.py
+    */settings.py
+    */wsgi.py
+    */asgi.py
+    */manage.py
+
+[report]
+show_missing = True
+skip_covered = True

backend/.coveragerc

@@ -1,19 +1,36 @@
 from django.contrib import admin
-from .models import Booking, Review
+from .models import Booking, Review, Availability
 
 @admin.register(Booking)
 class BookingsAdmin(admin.ModelAdmin):
-    list_display = ('session_date', 'tutor', 'student', 'booking_status')
-    search_fields = ('tutor__username', 'student__username', 'session_date')
+    list_display = ('student', 'get_tutor', 'booking_status')
+    search_fields = ('availability__tutor__profile__user__username', 'student__username')
     list_filter = ('booking_status',)
 
+    def get_tutor(self, obj):
+        """Displays tutor username in the admin panel."""
+        return obj.availability.tutor.profile.user.username
+
+    get_tutor.short_description = 'Tutor'  # Renames column in admin panel
+
+@admin.register(Availability)
+class AvailabilityAdmin(admin.ModelAdmin):
+    list_display = ('tutor', 'start_time', 'end_time', 'is_booked')
+    search_fields = ('tutor__profile__user__username',)  # Allows searching by tutor's username
+    list_filter = ('is_booked',)
+
 @admin.register(Review)
 class ReviewAdmin(admin.ModelAdmin):
-    list_display = ['tutor', 'reviewer', 'rating', 'feedback', 'is_visible', 'is_moderated', 'created_at']
+    list_display = ['get_tutor', 'reviewer', 'rating', 'feedback', 'is_visible', 'is_moderated', 'created_at']
     list_filter = ['is_visible', 'is_moderated', 'rating']
-    search_fields = ['reviewer__username', 'feedback']
+    search_fields = ['tutor__profile__user__username', 'reviewer__username', 'feedback']
     list_editable = ['is_visible', 'is_moderated']  # Allow inline editing
 
+    def get_tutor(self, obj):
+        """Displays tutor username in the admin panel."""
+        return obj.tutor.profile.user.username
+    get_tutor.short_description = 'Tutor'  # Renames column in admin panel
+
     def make_visible(self, request, queryset):
         queryset.update(is_visible=True)
 

backend/apps/bookings/admin.py

@@ -0,0 +1,16 @@
+from django.db import models
+from django.utils.timezone import now
+from datetime import timedelta
+
+class BookingManager(models.Manager):
+    def get_bookings_by_status(cls, status):
+        return cls.objects.filter(booking_status=status)
+
+    def is_expired(self):
+        return self.availability.start_time < now()
+
+class ReviewManager(models.Manager):
+    def average_rating(self, tutor):
+        reviews = self.filter(tutor=tutor)
+        total = sum([review.rating for review in reviews])
+        return total / len(reviews) if reviews else 0

backend/apps/bookings/managers.py

@@ -0,0 +1,66 @@
+# Generated by Django 5.1.6 on 2025-04-07 04:03
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('bookings', '0005_alter_booking_student_alter_review_unique_together'),
+        ('users', '0009_alter_tutorprofile_rating'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Availability',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('start_time', models.DateTimeField()),
+                ('end_time', models.DateTimeField()),
+                ('is_booked', models.BooleanField(default=False)),
+            ],
+            options={
+                'ordering': ['start_time', 'tutor'],
+            },
+        ),
+        migrations.AlterModelOptions(
+            name='booking',
+            options={},
+        ),
+        migrations.RemoveConstraint(
+            model_name='booking',
+            name='unique_session_per_tutor',
+        ),
+        migrations.RemoveField(
+            model_name='booking',
+            name='session_date',
+        ),
+        migrations.RemoveField(
+            model_name='booking',
+            name='session_end_time',
+        ),
+        migrations.RemoveField(
+            model_name='booking',
+            name='tutor',
+        ),
+        migrations.AlterField(
+            model_name='review',
+            name='tutor',
+            field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='reviews', to='users.tutorprofile'),
+        ),
+        migrations.AddField(
+            model_name='availability',
+            name='tutor',
+            field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='availabilities', to='users.tutorprofile'),
+        ),
+        migrations.AddField(
+            model_name='booking',
+            name='availability',
+            field=models.OneToOneField(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='availability_booking', to='bookings.availability'),
+        ),
+        migrations.AddConstraint(
+            model_name='availability',
+            constraint=models.UniqueConstraint(fields=('start_time', 'tutor'), name='unique_time_slot'),
+        ),
+    ]

backend/apps/bookings/migrations/0006_availability_alter_booking_options_and_more.py

@@ -5,8 +5,30 @@
 from datetime import timedelta
 from django.utils.timezone import now
 from rest_framework.exceptions import ValidationError
+from apps.users.models import TutorProfile
+from apps.bookings.managers import ReviewManager, BookingManager
 
 
+class Availability(models.Model):
+    """Defines available time slots for tutors."""
+    tutor = models.ForeignKey(TutorProfile, on_delete=models.CASCADE, related_name="availabilities")
+    start_time = models.DateTimeField()
+    end_time = models.DateTimeField()
+    is_booked = models.BooleanField(default=False)
+
+    def __str__(self):
+        return f"Availability: {self.tutor.profile.user.username} from {self.start_time} to {self.end_time}"
+
+    def clean(self):
+        if self.end_time <= self.start_time:
+            raise ValidationError("End time must be after start time.")
+
+    class Meta:
+        constraints = [
+            models.UniqueConstraint(fields=['start_time', 'tutor'], name='unique_time_slot')
+        ]
+        ordering = ['start_time', 'tutor']
+
 class Booking(models.Model):
     PENDING = 'Pending'
     APPROVED = 'Approved'
@@ -24,89 +46,83 @@ class Booking(models.Model):
         (FULFILLED, 'Fulfilled'),
     ]
 
-    session_date = models.DateTimeField()
     session_updated_at = models.DateTimeField(auto_now=True)
-    session_end_time = models.DateTimeField(null=True)
     booking_status = models.CharField(max_length=20, choices=BOOKING_STATUS_TYPES, default=PENDING)
     session_price = models.DecimalField(max_digits=10, decimal_places=2)
     student = models.ForeignKey(User, on_delete=models.CASCADE, related_name="student_bookings")
-    tutor = models.ForeignKey(User, on_delete=models.CASCADE, related_name="tutor")
     description = models.TextField(null=True, blank=True)
     payment_gateway_ref = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    availability = models.OneToOneField(Availability, on_delete=models.CASCADE, related_name="availability_booking", null=True, blank=True)
 
-    class Meta:
-        constraints = [
-            models.UniqueConstraint(fields=['session_date', 'tutor'], name='unique_session_per_tutor')
-        ]
-        ordering = ['session_date', 'tutor']
+    objects = BookingManager()
 
     def __str__(self):
-        return (f'Booking on {self.session_date.strftime("%Y-%m-%d %H:%M")} '
-                f'with {self.tutor.username} - {self.booking_status}')
+        return (f'Booking for {self.student.username} with {self.availability.tutor.profile.user.username} '
+                f'on {self.availability.start_time} - {self.booking_status}')
 
     def is_paid(self):
         return self.payment_gateway_ref is not None
 
-    def reschedule_booking(self, new_date):
-        if self.session_date < now():
+    def reschedule_booking(self, new_availability):
+        if self.availability.start_time < now():
             return False
-        self.session_date = new_date
-        self.save()
+        self.availability = new_availability
+        self.save(update_fields=['availability'])
+        return True
 
     def cancel_booking(self):
-        if self.session_date < now():
+        if self.availability.start_time < now():
             return False
-        self.booking_status = self.REJECTED
+        self.booking_status = self.CANCELLED
+        self.availability.is_booked = False  # Mark slot as available again
+        self.availability.save(update_fields=['is_booked'])
         self.save(update_fields=['booking_status'])
         return True
 
     def booking_duration(self):
-        if not self.session_end_time:
+        if not self.availability.end_time:
             return timedelta(0)
-        return self.session_end_time - self.session_date
-
-    @classmethod
-    def get_bookings_by_status(cls, status):
-        return cls.objects.filter(booking_status=status)
-
-    def is_expired(self):
-        return self.session_end_time < now()
+        return self.availability.end_time - self.availability.start_time
 
     def clean(self):
-        if self.session_end_time <= self.session_date:
+        if self.availability.end_time <= self.availability.start_time:
             raise ValidationError("Session end time must be after the session start time.")
+        elif self.availability.is_booked:
+            raise ValidationError("This time slot is already booked.")
 
     def save(self, *args, **kwargs):
         """Run full validation before saving."""
         self.full_clean()  # Ensures validation runs before saving
-        super().save(*args, **kwargs)
+        self.availability.is_booked = True
+
+        if not self.availability:
+            self.availability = Availability.objects.create(
+                tutor=self.student.Tu,  # Assuming student books a tutor
+                start_time=self.session_date,
+                end_time=self.session_end_time or (self.session_date + timedelta(hours=1)),
+                is_booked=True
+            )
 
+        super().save(*args, **kwargs)
 
 class Review(models.Model):
-    tutor = models.ForeignKey(User, on_delete=models.CASCADE, related_name="reviews")
+    tutor = models.ForeignKey(TutorProfile, on_delete=models.CASCADE, related_name="reviews")
     reviewer = models.ForeignKey(User, on_delete=models.CASCADE, related_name="reviewer")
     rating = models.PositiveSmallIntegerField(validators=[MinValueValidator(1), MaxValueValidator(5)])
     feedback = models.TextField(null=True, blank=True)
     created_at = models.DateTimeField(auto_now_add=True)
 
     is_visible = models.BooleanField(default=True)  # Whether the review is visible to others
-    is_moderated = models.BooleanField(
-        default=False)  # Whether the review has been moderated (e.g., checked for inappropriate content)
+    is_moderated = models.BooleanField(default=False)
+
+    objects = ReviewManager()
 
     def __str__(self):
-        return f"Review for {self.tutor.username} by {self.reviewer.username}"
+        return f"Review for {self.tutor.profile.user.username} by {self.reviewer.username}"
 
     class Meta:
-        ordering = ['-created_at']  # Sort reviews by most recent first
+        ordering = ['-created_at']
         unique_together = ('tutor', 'reviewer')
 
     def is_valid_review(self):
-        """Checks if the review has a valid rating and comments."""
         return self.rating is not None and self.feedback.strip() != ""
-
-    @staticmethod
-    def average_rating(tutor):
-        """Calculates the average rating for a tutor based on all reviews."""
-        reviews = Review.objects.filter(tutor=tutor)
-        total_rating = sum([review.rating for review in reviews])
-        return total_rating / len(reviews) if reviews else 0