Merge pull request #86 from UNLV-CS472-672/filters-for-search

PR 3: Filters for search and new ProfilePicture model

Author: ashley-arellano

backend/apps/search/models.py

@@ -1,6 +1,10 @@
 from django.db import models
+from django.conf import settings
 
 # Create your models here.
+
+# A model that represents the possible categories that a subject can belong to
+# (i.e. Category: Math can have Subjects: Calculus, Linear Algebra)
 class Category(models.Model):
     title = models.CharField(max_length=100)
 
@@ -11,12 +15,10 @@ def get_default_category():
     # Assuming the default tutor is the first tutor in the database
     return Category.objects.first()
 
+# A model that represents the possible subjects a tutor teaches
 class Subject(models.Model):
     title = models.CharField(max_length=100, unique=True)
     category = models.ForeignKey(Category, on_delete=models.CASCADE, related_name="subjects", default = get_default_category)
 
     def __str__(self):
         return self.title
-
-
-

backend/apps/search/serializers.py

@@ -1,11 +1,20 @@
 from rest_framework import serializers
 from apps.users.models import TutorProfile
+from apps.uploads.models import UploadRecord
 
 class TutorSearchResultSerializer(serializers.ModelSerializer):
     # Define custom fields to fetch first and last names from the related user profile
     first_name = serializers.CharField(source="profile.user.first_name")
     last_name = serializers.CharField(source="profile.user.last_name")
+    image_url = serializers.SerializerMethodField()  # Custom field to get the file URL
+
     # Specify the model and fields to be included in the serialized output
     class Meta:
         model = TutorProfile
-        fields = ["first_name", "last_name", "bio", "hourly_rate", "state", "city"]
+        fields = ["first_name", "last_name", "bio", "hourly_rate", "state", "city", "rating", "image_url"]
+
+    def get_image_url(self, result_data):
+        # Ensure that the profile and profile_picture exist before accessing them
+        if hasattr(result_data, "profile") and hasattr(result_data.profile, "upload_record"):
+            return UploadRecord.objects.build_url(result_data.profile.upload_record)
+        return None  # Return None if there's no profile picture

backend/apps/search/tests.py

@@ -24,7 +24,7 @@ def setUp(self):
         self.subject_geometry= Subject.objects.create(title="Geometry", category = self.category_math)
 
         # Create test tutor profiles
-        self.tutor = TutorProfile.objects.create_tutor_profile(profile=self.test_profile, city="New York", state="NY", hourly_rate=25.0)
+        self.tutor = TutorProfile.objects.create(profile=self.test_profile, city="New York", state="NY", hourly_rate=25.0)
 
         # Link tutors to subjects
         self.tutor.subjects.add(self.subject_geometry)

backend/apps/search/views.py

@@ -6,7 +6,7 @@
 import re
 from .models import Subject, Category
 from apps.users.models import TutorProfile
-from apps.users.managers import TutorProfileManager
+from apps.uploads.models import UploadRecord
 from .serializers import TutorSearchResultSerializer
 
 # Create your views here.
@@ -29,29 +29,83 @@ def get(self, request, format=None):
         except Exception as e:
             return Response({"message": f"Error parsing location: {str(e)}"}, status=status.HTTP_400_BAD_REQUEST)
 
-        # Filter tutors by location
-        filtered_tutors = TutorProfile.objects.filter_tutors_by_location(what, city, state)
-        # Perform search with 'what' term
-        search_results = TutorProfile.objects.search(filtered_tutors, what)
+        # Apply all filters before searching with django-watson
+
+        # Filter tutors by location (Required)
+        filtered_tutors = TutorProfile.objects.filter_tutors_by_location(city, state)
+
+        # Filter tutors by pay (Optional)
+        min_price = request.query_params.get('min-price', "").strip()
+        max_price = request.query_params.get('max-price', "").strip()
+
+        try:
+            # Convert from string to float
+            min_price = float(min_price) if min_price else None
+            max_price = float(max_price) if max_price else None
+
+            # Check if max price is not less than min price
+            if min_price is not None and max_price is not None and max_price < min_price:
+                return Response({"message": "Max price cannot be less than min price."}, status=status.HTTP_400_BAD_REQUEST)
+
+            # Filter based of price range
+            filtered_tutors = TutorProfile.objects.filter_by_price_range(filtered_tutors, min_price, max_price)
+
+        except ValueError:
+            return Response({"message": "Price filters must be valid numbers."}, status=status.HTTP_400_BAD_REQUEST)
+
+
+        # Filter tutors by rating (Optional)
+        rating = request.query_params.get('rating', "").strip()
+        if rating:
+            try:
+                # Convert from string to int
+                rating = int(rating)
+                # Filter based of rating (i.e. 4 stars and up, 3 stars and up, etc)
+                filtered_tutors = TutorProfile.objects.filter_tutors_by_rating(filtered_tutors, rating)
+
+            except ValueError:
+                return Response({"message": "Invalid value for rating. It must be a number."}, status=status.HTTP_400_BAD_REQUEST)
+
+        is_subjects_filtered = False
+        query = Q()
+
+        # Get subjects from request
+        subjects = request.query_params.get('subjects', "").strip()
+        # Filter tutors by subject (Optional)
+        if subjects:
+            subject_list = subjects.split(",")  # Assuming subjects are comma-separated
+            # Execute the query for subjects
+            query = Subject.objects.filter(Q(title__in=subject_list))
+            filtered_tutors = TutorProfile.objects.filter_tutors_by_subject(filtered_tutors, query, is_subjects_filtered)
+            is_subjects_filtered = True
 
         # Split the 'what' search term into individual words, handling non-word characters and spaces
-        # This helps match partial words that django-watson might overlook
+        # This helps match partial words regarding subject and is used to pull up other
+        # tutor results whose subjects fits this search term
         search_terms = re.split(r'[\W\s]+', what)
-        query = Q()
+        lookup_subjects_query = Q()
+        # This helps match partial names regarding tutors
+        lookup_tutors_query = Q()
 
         # Loop through each search term and create a query that checks if the term is
         # in the category title or the subject title
         for term in search_terms:
-            query |= Q(category__title__icontains=term) | Q(title__icontains=term)
+            lookup_subjects_query |= Q(category__title__icontains=term) | Q(title__icontains=term)
+            lookup_tutors_query |= Q(profile__user__first_name__icontains=term) | Q(profile__user__last_name__icontains=term)
+
+        # Perform search with 'what' term
+        search_results = TutorProfile.objects.search(filtered_tutors, what)
+        # Combine with partial_tutor_matches
+        partial_tutor_matches = TutorProfile.objects.filter(lookup_tutors_query)
+        search_results = (search_results | partial_tutor_matches)
 
         try:
-            # Attempt to filter subjects based on the search query
-            subject_query = Subject.objects.filter(query)
-            # If matching subjects are found, filter tutors by these subjects
-            if subject_query.exists():
-                filtered_tutors = TutorProfile.objects.filter_tutors_by_subject(filtered_tutors, subject_query)
-                # Combine the filtered tutors with the existing search results
-                search_results = (filtered_tutors | search_results).distinct()
+            # Execute the query for subjects
+            subject_query = Subject.objects.filter(lookup_subjects_query)
+            filtered_tutors = TutorProfile.objects.filter_tutors_by_subject(filtered_tutors, subject_query, is_subjects_filtered)
+            # Combine the filtered tutors with the existing search results
+            search_results = (search_results | filtered_tutors).distinct()
+
         except Exception as e:
             return Response({"message": f"Error searching subjects: {str(e)}"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 

backend/apps/submissions/tests.py

@@ -29,7 +29,7 @@ def setUp(self):
             "version": 1,
             "asset_id": "sample_asset_id"
         }
-        self.upload_record = UploadRecord.objects.create(upload_data=self.upload_data, user=self.user)
+        self.upload_record = UploadRecord.objects.create(upload_data=self.upload_data, profile=self.profile)
 
         # Create submission
         self.submission = Submissions.objects.create(

backend/apps/uploads/admin.py

@@ -1,10 +1,11 @@
 # uploads/admin.py
 from django.contrib import admin
-from apps.uploads.models import UploadRecord
+from apps.uploads.models import UploadRecord, ProfilePicture
 # Debug Only: Shows public_id and id in localhost/admin
 
 
 class UploadRecordAdmin(admin.ModelAdmin):
-    list_display=['public_id', 'id']
+    list_display=['cloudinary_public_id', 'id']
 # Register your models here.
 admin.site.register(UploadRecord, UploadRecordAdmin)
+admin.site.register(ProfilePicture)

backend/apps/uploads/managers.py

@@ -4,6 +4,16 @@
 import cloudinary.uploader
 from cloudinary import CloudinaryImage
 
+class ProfilePictureManager(models.Manager):
+    def create(self, upload):
+        # Create a new UploadRecord instance with the provided data
+        profile_picture = self.model(
+                upload=upload
+            )
+        # Save the instance to the database
+        profile_picture.save()
+        return profile_picture
+
 class UploadRecordManager(models.Manager):
 
     def upload(self, file):
@@ -16,7 +26,7 @@ def delete_upload(self, cloudinary_public_id):
         result = cloudinary.uploader.destroy(cloudinary_public_id, invalidate = True)
         return result
 
-    def create(self, upload_data, user):
+    def create(self, upload_data, profile):
         # Replace 'Z' with '+00:00' for compatibility with fromisoformat
         compatible_created_at = upload_data['created_at'].replace('Z', '+00:00')
         # Convert to datetime object
@@ -30,9 +40,9 @@ def create(self, upload_data, user):
             file_format=upload_data["format"],
             created_at=created_at_datetime,
             cloudinary_public_id=upload_data["public_id"],
-            user=user,
             version=upload_data["version"],
-            asset_id=upload_data["asset_id"]
+            asset_id=upload_data["asset_id"],
+            profile=profile
         )
         # Save the instance to the database
         upload_record.save()
@@ -45,9 +55,9 @@ def build_url(self, upload):
         dynamic_asset_url, _ = cloudinary.utils.cloudinary_url(cloudinary_public_id, resource_type = resource_type)
         return dynamic_asset_url
 
-    def get_upload(self,public_id):
+    def get_upload(self, cloudinary_public_id):
         # Retrieve the upload record by its public ID
-        upload_record = self.get_queryset().filter(public_id=public_id).first()
+        upload_record = self.get_queryset().filter(cloudinary_public_id=cloudinary_public_id).first()
         return upload_record
 
     def get_all_uploads(self):

backend/apps/uploads/migrations/0005_remove_uploadrecord_public_id_and_more.py

@@ -0,0 +1,31 @@
+# Generated by Django 5.1.6 on 2025-03-25 22:24
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('uploads', '0004_remove_uploadrecord_profile_uploadrecord_user'),
+        ('users', '0008_tutorprofile_rating'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='uploadrecord',
+            name='public_id',
+        ),
+        migrations.RemoveField(
+            model_name='uploadrecord',
+            name='user',
+        ),
+        migrations.CreateModel(
+            name='ProfilePicture',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('profile', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='profile_picture', to='users.profile')),
+                ('upload', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, to='uploads.uploadrecord')),
+            ],
+        ),
+    ]

backend/apps/uploads/migrations/0006_remove_profilepicture_profile_uploadrecord_profile.py

@@ -0,0 +1,25 @@
+# Generated by Django 5.1.6 on 2025-03-26 04:21
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('uploads', '0005_remove_uploadrecord_public_id_and_more'),
+        ('users', '0009_alter_tutorprofile_rating'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='profilepicture',
+            name='profile',
+        ),
+        migrations.AddField(
+            model_name='uploadrecord',
+            name='profile',
+            field=models.OneToOneField(default=1, on_delete=django.db.models.deletion.CASCADE, related_name='profile', to='users.profile'),
+            preserve_default=False,
+        ),
+    ]

backend/apps/uploads/migrations/0007_alter_uploadrecord_profile.py

@@ -0,0 +1,20 @@
+# Generated by Django 5.1.6 on 2025-03-26 04:49
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('uploads', '0006_remove_profilepicture_profile_uploadrecord_profile'),
+        ('users', '0009_alter_tutorprofile_rating'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='uploadrecord',
+            name='profile',
+            field=models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='upload_record', to='users.profile'),
+        ),
+    ]