gcivil-nyu-org / INT2-Monday-Spring2024-Team-2 / 809

Committed 04 May 2024 03:36PM UTC coverage: 91.716%. Remained the same

Build # 809

Build Type

Pull #253

travis-pro

Committed by

web-flow

Commit Message

Merge 26fc3c1b5 into 48120f46f

Pull Request Pull Request #253: Survey

Run Details

2015 of 2197 relevant lines covered (91.72%)

1.37 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.63

/TutorFilter/views.py

from django.shortcuts import render, get_object_or_404, redirect
from .forms import TutorFilterForm, TutoringSessionRequestForm
from TutorRegister.models import (
    ProfileT,
    Availability,
    Expertise,
    UserType,
    ProfileS,
    TutoringSession,
    TutorReview,
    Favorite,
)
from django.contrib.auth.models import User
from django.conf import settings
from django.http import JsonResponse
from datetime import datetime, timedelta
import json
from django.db.models import Avg
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger


def filter_tutors(request):
    form = TutorFilterForm(request.GET, user=request.user)
    users_expertise = Expertise.objects.all()
    users = ProfileT.objects.all().filter(qualified=True)
    favorites = Favorite.objects.all().filter(student=request.user)
    tutor_ratings = {user.user_id: float(0.0) for user in users}  # Default rating is 0
    average_ratings = TutorReview.objects.values("tutor_id").annotate(
        average_rating=Avg("rating")
    )
    for rating in average_ratings:
        tutor_ratings[rating["tutor_id"]] = round(rating["average_rating"], 1)

    has_profile = (
        UserType.objects.all()
        .filter(has_profile_complete=True)
        .values_list("user", flat=True)
    )
    users = users.filter(user__in=has_profile)

    # users.sort(key=lambda x: sorted_tutors_ids.index(x.id))

    if form.is_valid():
        if form.cleaned_data["expertise"] and form.cleaned_data["expertise"] != "..":
            users_expertise_id = users_expertise.filter(
                subject=form.cleaned_data["expertise"]
            ).values_list("user", flat=True)
            users = users.filter(user__in=users_expertise_id)
        if form.cleaned_data["preferred_mode"]:
            if form.cleaned_data["preferred_mode"] != "..":
                users = users.filter(preferred_mode=form.cleaned_data["preferred_mode"])
        if form.cleaned_data["grade"] and form.cleaned_data["grade"] != "..":
            users = users.filter(grade=form.cleaned_data["grade"])
        if form.cleaned_data["zipcode"] and form.cleaned_data["zipcode"] != "..":
            users = users.filter(zip=form.cleaned_data["zipcode"])
        if form.cleaned_data["salary_max"]:
            users = users.filter(salary_min__lt=form.cleaned_data["salary_max"])
        if form.cleaned_data["rating"]:
            if form.cleaned_data["rating"] == ">= 1 star":
                high_rating_tutors = {
                    user: rating
                    for user, rating in tutor_ratings.items()
                    if rating >= 1
                }
                users = users.filter(user_id__in=high_rating_tutors.keys())
            elif form.cleaned_data["rating"] == ">= 2 stars":
                high_rating_tutors = {
                    user: rating
                    for user, rating in tutor_ratings.items()
                    if rating >= 2
                }
                users = users.filter(user_id__in=high_rating_tutors.keys())
            elif form.cleaned_data["rating"] == ">= 3 stars":
                high_rating_tutors = {
                    user: rating
                    for user, rating in tutor_ratings.items()
                    if rating >= 3
                }
                users = users.filter(user_id__in=high_rating_tutors.keys())
            elif form.cleaned_data["rating"] == ">= 4 stars":
                high_rating_tutors = {
                    user: rating
                    for user, rating in tutor_ratings.items()
                    if rating >= 4
                }
                users = users.filter(user_id__in=high_rating_tutors.keys())
            elif form.cleaned_data["rating"] == "= 5 stars":
                high_rating_tutors = {
                    user: rating
                    for user, rating in tutor_ratings.items()
                    if rating >= 5
                }
                users = users.filter(user_id__in=high_rating_tutors.keys())
        if form.cleaned_data["category"]:
            category = form.cleaned_data["category"]
            if category != "..":
                users = users
                users_favorite_id = favorites.filter(category=category).values_list(
                    "tutor", flat=True
                )
                users = users.filter(user__in=users_favorite_id)
        if form.cleaned_data["sortBy"]:
            if form.cleaned_data["sortBy"] == "Highest Rating":
                users = list(users)
                users.sort(
                    key=lambda tutor: tutor_ratings.get(tutor.user_id, 0), reverse=True
                )
            elif form.cleaned_data["sortBy"] == "Highest Price":
                users = users.order_by("-salary_max")
            elif form.cleaned_data["sortBy"] == "Lowest Price":
                users = users.order_by("salary_max")
    categories = list(set(favorites.values_list("category", flat=True)))
    favorites = favorites.values_list("tutor", flat=True)

    paginator = Paginator(users, 12)
    page = request.GET.get("page")
    salary_max = (
        ""
        if form.cleaned_data["salary_max"] is None
        else form.cleaned_data["salary_max"]
    )
    print(salary_max)
    try:
        users = paginator.page(page)
    except PageNotAnInteger:
        # If page is not an integer, deliver first page.
        users = paginator.page(1)
    except EmptyPage:
        # If page is out of range, deliver last page of results.
        users = paginator.page(paginator.num_pages)
    return render(
        request,
        "TutorFilter/filter_results.html",
        {
            "form": form,
            "users": users,
            "average_ratings": tutor_ratings.items(),
            "favorites": favorites,
            "categories": categories,
            "page": page,
            "preferred_mode": form.cleaned_data["preferred_mode"],
            "grade": form.cleaned_data["grade"],
            "expertise": form.cleaned_data["expertise"],
            "rating": form.cleaned_data["rating"],
            "zipcode": form.cleaned_data["zipcode"],
            "salary_max": salary_max,
            "category": form.cleaned_data["category"],
            "sort_By": form.cleaned_data["sortBy"],
            "MEDIA_URL": settings.MEDIA_URL,
        },
    )


def add_favorite(request):
    if request.method == "POST":
        category_name = request.POST.get("category_name")
        tutor_id = request.POST.get("tutor_id")
        # print(tutor_id)
        # print(category_name)
        tutor = ProfileT.objects.all().filter(user__id=tutor_id)[:1].get().user
        # Now, you can add this to your database
        new_record = Favorite(category=category_name, student=request.user, tutor=tutor)
        new_record.save()

        return JsonResponse(
            {"status": "success", "message": "Add the tutor successfully!"}
        )
    else:
        return JsonResponse({"status": "error", "message": "Invalid request"})


def remove_favorite(request):
    if request.method == "POST":
        tutor_id = request.POST.get("tutor_id")
        tutor = ProfileT.objects.all().filter(user__id=tutor_id)[:1].get().user
        Favorite.objects.filter(student=request.user, tutor=tutor).delete()

        return JsonResponse(
            {"status": "success", "message": "Remove the tutor successfully!"}
        )
    else:
        return JsonResponse({"status": "error", "message": "Invalid request"})


def get_type(user_id):
    u_t = get_object_or_404(UserType, user=user_id)
    t = u_t.user_type

    return t


def view_profile(request, user_id):
    type = get_type(user_id)

    if type == "tutor":
        return view_tutor_profile(request, user_id)

    elif type == "student":
        return view_student_profile(request, user_id)


def view_tutor_profile(request, user_id):
    profilet = get_object_or_404(ProfileT, user=user_id)
    expertise = Expertise.objects.all().filter(user=profilet.user)

    expertises = [get_display_expertise(e.subject) for e in expertise]

    availability = Availability.objects.all().filter(user=profilet.user)

    reviews = (
        TutorReview.objects.all()
        .filter(tutor_id=user_id)
        .select_related("student_id__profiles")
    )

    average_rating = reviews.aggregate(Avg("rating"))["rating__avg"] or 0

    page = request.GET.get("page")
    paginator = Paginator(reviews, 5)
    try:
        review_pag = paginator.page(page)
    except PageNotAnInteger:
        # If page is not an integer, deliver first page.
        review_pag = paginator.page(1)
    except EmptyPage:
        # If page is out of range, deliver last page of results.
        review_pag = paginator.page(paginator.num_pages)
    return render(
        request,
        "TutorFilter/view_tutor_profile.html",
        {
            "profilet": profilet,
            "expertise": expertises,
            "availability": availability,
            "reviews": review_pag,
            "has_review": reviews,
            "average_rating": average_rating,
            "MEDIA_URL": settings.MEDIA_URL,
        },
    )


def view_student_profile(request, user_id):
    profiles = get_object_or_404(ProfileS, user=user_id)

    return render(
        request,
        "TutorFilter/view_student_profile.html",
        {
            "profiles": profiles,
            "MEDIA_URL": settings.MEDIA_URL,
        },
    )


def get_display_expertise(expertise):
    expertise_dict = dict(TutorFilterForm.EXPERTISE_CHOICES)

    return expertise_dict.get(expertise, expertise)


def request_tutoring_session(request, tutor_id):
    tutor_user = get_object_or_404(User, pk=tutor_id)
    tutor_profile = get_object_or_404(ProfileT, user=tutor_user)
    availabilities = Availability.objects.filter(user_id=tutor_id)

    if request.method == "POST":
        form = TutoringSessionRequestForm(
            request.POST, request.FILES, tutor_user=tutor_user
        )
        if form.is_valid():
            selected_timeslots = json.loads(
                request.POST.get("selected_timeslots", "[]")
            )
            for timeslot in selected_timeslots:
                tutoring_session = TutoringSession(
                    student_id=request.user,
                    tutor_id=tutor_user,
                    tutoring_mode=form.cleaned_data["tutoring_mode"],
                    subject=form.cleaned_data["subject"],
                    date=form.cleaned_data["date"],
                    start_time=datetime.strptime(timeslot["start"], "%H:%M").time(),
                    end_time=datetime.strptime(timeslot["end"], "%H:%M").time(),
                    offering_rate=form.cleaned_data["offering_rate"],
                    message=form.cleaned_data["message"],
                    attachment=form.cleaned_data.get(
                        "attachment"
                    ),  # Include the attachment
                    status="Pending",
                )
                tutoring_session.save()

            return redirect("Dashboard:dashboard")
    else:
        form = TutoringSessionRequestForm(tutor_user=tutor_user)

    return render(
        request,
        "TutorFilter/request_tutoring_session.html",
        {"form": form, "tutor": tutor_profile, "availabilities": availabilities},
    )


def get_available_times(request, tutor_id, selected_date):
    if request.method == "POST":
        selected_date_obj = datetime.strptime(selected_date, "%Y-%m-%d").date()
        day_of_week = selected_date_obj.strftime("%A")
        day = day_of_week
        availabilities = Availability.objects.filter(
            user_id=tutor_id, day_of_week=day.lower()
        )
        booked_sessions = TutoringSession.objects.filter(
            tutor_id=tutor_id, date=selected_date, status="Accepted"
        )
        available_slots = []
        for availability in availabilities:
            start = datetime.combine(selected_date_obj, availability.start_time)
            end = datetime.combine(selected_date_obj, availability.end_time)

            current = start
            while current < end:
                slot_end = current + timedelta(minutes=30)
                if not booked_sessions.filter(
                    start_time__lt=slot_end.time(), end_time__gt=current.time()
                ).exists():
                    available_slots.append(current.strftime("%H:%M"))
                current = slot_end
        return JsonResponse({"available_slots": available_slots, "day": day.lower()})

1	from django.shortcuts import render, get_object_or_404, redirect	2✔
2	from .forms import TutorFilterForm, TutoringSessionRequestForm	2✔
3	from TutorRegister.models import (	2✔
4	ProfileT,
5	Availability,
6	Expertise,
7	UserType,
8	ProfileS,
9	TutoringSession,
10	TutorReview,
11	Favorite,
12	)
13	from django.contrib.auth.models import User	2✔
14	from django.conf import settings	2✔
15	from django.http import JsonResponse	2✔
16	from datetime import datetime, timedelta	2✔
17	import json	2✔
18	from django.db.models import Avg	2✔
19	from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger	2✔
20
21
22	def filter_tutors(request):	2✔
23	form = TutorFilterForm(request.GET, user=request.user)	1✔
24	users_expertise = Expertise.objects.all()	1✔
25	users = ProfileT.objects.all().filter(qualified=True)	1✔
26	favorites = Favorite.objects.all().filter(student=request.user)	1✔
27	tutor_ratings = {user.user_id: float(0.0) for user in users} # Default rating is 0	1✔
28	average_ratings = TutorReview.objects.values("tutor_id").annotate(	1✔
29	average_rating=Avg("rating")
30	)
31	for rating in average_ratings:	1✔
32	tutor_ratings[rating["tutor_id"]] = round(rating["average_rating"], 1)	×
33
34	has_profile = (	1✔
35	UserType.objects.all()
36	.filter(has_profile_complete=True)
37	.values_list("user", flat=True)
38	)
39	users = users.filter(user__in=has_profile)	1✔
40
41	# users.sort(key=lambda x: sorted_tutors_ids.index(x.id))
42
43	if form.is_valid():	1✔
44	if form.cleaned_data["expertise"] and form.cleaned_data["expertise"] != "..":	1✔
45	users_expertise_id = users_expertise.filter(	1✔
46	subject=form.cleaned_data["expertise"]
47	).values_list("user", flat=True)
48	users = users.filter(user__in=users_expertise_id)	1✔
49	if form.cleaned_data["preferred_mode"]:	1✔
50	if form.cleaned_data["preferred_mode"] != "..":	1✔
51	users = users.filter(preferred_mode=form.cleaned_data["preferred_mode"])	1✔
52	if form.cleaned_data["grade"] and form.cleaned_data["grade"] != "..":	1✔
53	users = users.filter(grade=form.cleaned_data["grade"])	1✔
54	if form.cleaned_data["zipcode"] and form.cleaned_data["zipcode"] != "..":	1✔
55	users = users.filter(zip=form.cleaned_data["zipcode"])	1✔
56	if form.cleaned_data["salary_max"]:	1✔
57	users = users.filter(salary_min__lt=form.cleaned_data["salary_max"])	1✔
58	if form.cleaned_data["rating"]:	1✔
59	if form.cleaned_data["rating"] == ">= 1 star":	1✔
60	high_rating_tutors = {	1✔
61	user: rating
62	for user, rating in tutor_ratings.items()
63	if rating >= 1
64	}
65	users = users.filter(user_id__in=high_rating_tutors.keys())	1✔
66	elif form.cleaned_data["rating"] == ">= 2 stars":	1✔
67	high_rating_tutors = {	1✔
68	user: rating
69	for user, rating in tutor_ratings.items()
70	if rating >= 2
71	}
72	users = users.filter(user_id__in=high_rating_tutors.keys())	1✔
73	elif form.cleaned_data["rating"] == ">= 3 stars":	1✔
74	high_rating_tutors = {	1✔
75	user: rating
76	for user, rating in tutor_ratings.items()
77	if rating >= 3
78	}
79	users = users.filter(user_id__in=high_rating_tutors.keys())	1✔
80	elif form.cleaned_data["rating"] == ">= 4 stars":	1✔
81	high_rating_tutors = {	1✔
82	user: rating
83	for user, rating in tutor_ratings.items()
84	if rating >= 4
85	}
86	users = users.filter(user_id__in=high_rating_tutors.keys())	1✔
87	elif form.cleaned_data["rating"] == "= 5 stars":	1✔
88	high_rating_tutors = {	1✔
89	user: rating
90	for user, rating in tutor_ratings.items()
91	if rating >= 5
92	}
93	users = users.filter(user_id__in=high_rating_tutors.keys())	1✔
94	if form.cleaned_data["category"]:	1✔
95	category = form.cleaned_data["category"]	1✔
96	if category != "..":	1✔
97	users = users	×
98	users_favorite_id = favorites.filter(category=category).values_list(	×
99	"tutor", flat=True
100	)
101	users = users.filter(user__in=users_favorite_id)	×
102	if form.cleaned_data["sortBy"]:	1✔
103	if form.cleaned_data["sortBy"] == "Highest Rating":	1✔
104	users = list(users)	1✔
105	users.sort(	1✔
106	key=lambda tutor: tutor_ratings.get(tutor.user_id, 0), reverse=True
107	)
108	elif form.cleaned_data["sortBy"] == "Highest Price":	1✔
109	users = users.order_by("-salary_max")	1✔
110	elif form.cleaned_data["sortBy"] == "Lowest Price":	1✔
111	users = users.order_by("salary_max")	1✔
112	categories = list(set(favorites.values_list("category", flat=True)))	1✔
113	favorites = favorites.values_list("tutor", flat=True)	1✔
114
115	paginator = Paginator(users, 12)	1✔
116	page = request.GET.get("page")	1✔
117	salary_max = (	1✔
118	""
119	if form.cleaned_data["salary_max"] is None
120	else form.cleaned_data["salary_max"]
121	)
122	print(salary_max)	1✔
123	try:	1✔
124	users = paginator.page(page)	1✔
125	except PageNotAnInteger:	1✔
126	# If page is not an integer, deliver first page.
127	users = paginator.page(1)	1✔
128	except EmptyPage:	×
129	# If page is out of range, deliver last page of results.
130	users = paginator.page(paginator.num_pages)	×
131	return render(	1✔
132	request,
133	"TutorFilter/filter_results.html",
134	{
135	"form": form,
136	"users": users,
137	"average_ratings": tutor_ratings.items(),
138	"favorites": favorites,
139	"categories": categories,
140	"page": page,
141	"preferred_mode": form.cleaned_data["preferred_mode"],
142	"grade": form.cleaned_data["grade"],
143	"expertise": form.cleaned_data["expertise"],
144	"rating": form.cleaned_data["rating"],
145	"zipcode": form.cleaned_data["zipcode"],
146	"salary_max": salary_max,
147	"category": form.cleaned_data["category"],
148	"sort_By": form.cleaned_data["sortBy"],
149	"MEDIA_URL": settings.MEDIA_URL,
150	},
151	)
152
153
154	def add_favorite(request):	2✔
155	if request.method == "POST":	1✔
156	category_name = request.POST.get("category_name")	1✔
157	tutor_id = request.POST.get("tutor_id")	1✔
158	# print(tutor_id)
159	# print(category_name)
160	tutor = ProfileT.objects.all().filter(user__id=tutor_id)[:1].get().user	1✔
161	# Now, you can add this to your database
162	new_record = Favorite(category=category_name, student=request.user, tutor=tutor)	1✔
163	new_record.save()	1✔
164
165	return JsonResponse(	1✔
166	{"status": "success", "message": "Add the tutor successfully!"}
167	)
168	else:
169	return JsonResponse({"status": "error", "message": "Invalid request"})	×
170
171
172	def remove_favorite(request):	2✔
173	if request.method == "POST":	1✔
174	tutor_id = request.POST.get("tutor_id")	1✔
175	tutor = ProfileT.objects.all().filter(user__id=tutor_id)[:1].get().user	1✔
176	Favorite.objects.filter(student=request.user, tutor=tutor).delete()	1✔
177
178	return JsonResponse(	1✔
179	{"status": "success", "message": "Remove the tutor successfully!"}
180	)
181	else:
182	return JsonResponse({"status": "error", "message": "Invalid request"})	×
183
184
185	def get_type(user_id):	2✔
186	u_t = get_object_or_404(UserType, user=user_id)	1✔
187	t = u_t.user_type	1✔
188
189	return t	1✔
190
191
192	def view_profile(request, user_id):	2✔
193	type = get_type(user_id)	1✔
194
195	if type == "tutor":	1✔
196	return view_tutor_profile(request, user_id)	1✔
197
198	elif type == "student":	1✔
199	return view_student_profile(request, user_id)	1✔
200
201
202	def view_tutor_profile(request, user_id):	2✔
203	profilet = get_object_or_404(ProfileT, user=user_id)	1✔
204	expertise = Expertise.objects.all().filter(user=profilet.user)	1✔
205
206	expertises = [get_display_expertise(e.subject) for e in expertise]	1✔
207
208	availability = Availability.objects.all().filter(user=profilet.user)	1✔
209
210	reviews = (	1✔
211	TutorReview.objects.all()
212	.filter(tutor_id=user_id)
213	.select_related("student_id__profiles")
214	)
215
216	average_rating = reviews.aggregate(Avg("rating"))["rating__avg"] or 0	1✔
217
218	page = request.GET.get("page")	1✔
219	paginator = Paginator(reviews, 5)	1✔
220	try:	1✔
221	review_pag = paginator.page(page)	1✔
222	except PageNotAnInteger:	1✔
223	# If page is not an integer, deliver first page.
224	review_pag = paginator.page(1)	1✔
225	except EmptyPage:	×
226	# If page is out of range, deliver last page of results.
227	review_pag = paginator.page(paginator.num_pages)	×
228	return render(	1✔
229	request,
230	"TutorFilter/view_tutor_profile.html",
231	{
232	"profilet": profilet,
233	"expertise": expertises,
234	"availability": availability,
235	"reviews": review_pag,
236	"has_review": reviews,
237	"average_rating": average_rating,
238	"MEDIA_URL": settings.MEDIA_URL,
239	},
240	)
241
242
243	def view_student_profile(request, user_id):	2✔
244	profiles = get_object_or_404(ProfileS, user=user_id)	1✔
245
246	return render(	1✔
247	request,
248	"TutorFilter/view_student_profile.html",
249	{
250	"profiles": profiles,
251	"MEDIA_URL": settings.MEDIA_URL,
252	},
253	)
254
255
256	def get_display_expertise(expertise):	2✔
257	expertise_dict = dict(TutorFilterForm.EXPERTISE_CHOICES)	1✔
258
259	return expertise_dict.get(expertise, expertise)	1✔
260
261
262	def request_tutoring_session(request, tutor_id):	2✔
263	tutor_user = get_object_or_404(User, pk=tutor_id)	1✔
264	tutor_profile = get_object_or_404(ProfileT, user=tutor_user)	1✔
265	availabilities = Availability.objects.filter(user_id=tutor_id)	1✔
266
267	if request.method == "POST":	1✔
268	form = TutoringSessionRequestForm(	1✔
269	request.POST, request.FILES, tutor_user=tutor_user
270	)
271	if form.is_valid():	1✔
272	selected_timeslots = json.loads(	1✔
273	request.POST.get("selected_timeslots", "[]")
274	)
275	for timeslot in selected_timeslots:	1✔
276	tutoring_session = TutoringSession(	1✔
277	student_id=request.user,
278	tutor_id=tutor_user,
279	tutoring_mode=form.cleaned_data["tutoring_mode"],
280	subject=form.cleaned_data["subject"],
281	date=form.cleaned_data["date"],
282	start_time=datetime.strptime(timeslot["start"], "%H:%M").time(),
283	end_time=datetime.strptime(timeslot["end"], "%H:%M").time(),
284	offering_rate=form.cleaned_data["offering_rate"],
285	message=form.cleaned_data["message"],
286	attachment=form.cleaned_data.get(
287	"attachment"
288	), # Include the attachment
289	status="Pending",
290	)
291	tutoring_session.save()	1✔
292
293	return redirect("Dashboard:dashboard")	1✔
294	else:
295	form = TutoringSessionRequestForm(tutor_user=tutor_user)	1✔
296
297	return render(	1✔
298	request,
299	"TutorFilter/request_tutoring_session.html",
300	{"form": form, "tutor": tutor_profile, "availabilities": availabilities},
301	)
302
303
304	def get_available_times(request, tutor_id, selected_date):	2✔
305	if request.method == "POST":	1✔
306	selected_date_obj = datetime.strptime(selected_date, "%Y-%m-%d").date()	1✔
307	day_of_week = selected_date_obj.strftime("%A")	1✔
308	day = day_of_week	1✔
309	availabilities = Availability.objects.filter(	1✔
310	user_id=tutor_id, day_of_week=day.lower()
311	)
312	booked_sessions = TutoringSession.objects.filter(	1✔
313	tutor_id=tutor_id, date=selected_date, status="Accepted"
314	)
315	available_slots = []	1✔
316	for availability in availabilities:	1✔
317	start = datetime.combine(selected_date_obj, availability.start_time)	1✔
318	end = datetime.combine(selected_date_obj, availability.end_time)	1✔
319
320	current = start	1✔
321	while current < end:	1✔
322	slot_end = current + timedelta(minutes=30)	1✔
323	if not booked_sessions.filter(	1✔
324	start_time__lt=slot_end.time(), end_time__gt=current.time()
325	).exists():
326	available_slots.append(current.strftime("%H:%M"))	1✔
327	current = slot_end	1✔
328	return JsonResponse({"available_slots": available_slots, "day": day.lower()})	1✔

gcivil-nyu-org / INT2-Monday-Spring2024-Team-2 / 809

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous