def save_take(request):
now_instructor_pk, now_semester, now_take = "", "", ""
if request.method == "POST":
post = json.loads(request.body)
take, semester, delete = post['take'], post['semester'], post['delete']
course = get_object_or_404(Course, pk=post['course_pk'])
past_query = CourseUser.objects.filter(user=request.user, course = course)
if delete:
if past_query.first() != None:
past_query.first().delete()
return _success_response()
instructor = get_object_or_404(Instructor, pk=post['instructor_pk'])
cs_instr = get_object_or_404(CourseInstructor, pk=post["course_instructor_pk"])
if past_query.first() != None:
past_query.first().delete()
if not delete:
cs_user = CourseUser.objects.create(user=request.user, course = course, instructor = instructor, course_instructor = cs_instr)
now_instructor_pk, now_semester, now_take = cs_user.course_instructor.instructor.pk, cs_user.course_instructor.semester, cs_user.take
return _success_response({
"now":{
"instructor_pk":now_instructor_pk,
"semester":now_semester,
"take":now_take,
},
})
if request.method == "GET":
return _get_not_allowed()
def check_mentor_requirements(request):
if request.method == "GET":
dt = datetime.datetime.strptime(settings.HMP_CHECK_TIME, '%Y-%m-%d')
user_review_num = request.user.courseuser_set.annotate(
length=Length("text")).filter(length__gt=15, date__gt=dt).count()
if user_review_num < 3:
return _success_response({"valid": False})
return _success_response({"valid": True})
if request.method == "POST":
return _post_not_allowed()
def edit_plannable_profile(request, username):
if request.method == "POST":
try:
user = User.objects.get(username=username)
except:
return _error_response("User doesn't exist")
post = json.loads(request.body)
user_agent = request.META['HTTP_USER_AGENT']
action = post["action"]
# Rename profile and delete all previous versions
if action == "rename":
oldName, newName, content = post["oldName"], post["newName"], post["profile"]
try:
profile = PlanProfile.objects.get(user=user ,name=oldName)
except:
return _error_response("Profile doesn't exist")
new_profile = PlanProfile.objects.filter(user=user, name=newName).first()
# newName already exists, delete old profile and add new version to new profile it
if new_profile != None:
for p_v in profile.planprofileversion_set.all():
p_v.delete()
profile.delete()
PlanProfileVersion.objects.create(version=new_profile.latest + 1, content=content, plan_profile=new_profile, user_agent=user_agent)
new_profile.latest += 1
new_profile.save()
return _success_response({"versions":get_versions_of_profile(new_profile)})
# Delete(detach) previous versions
for p_v in profile.planprofileversion_set.all():
p_v.delete()
PlanProfileVersion.objects.create(version=1, content=content, plan_profile=profile, user_agent=user_agent)
profile.name = newName
profile.latest = 1
profile.save()
return _success_response({"versions":get_versions_of_profile(profile)})
# Delete profile and corresponding versions
elif action == "delete":
if "name" not in post:
return _error_response("Missing name field")
name = post["name"]
try:
profile = PlanProfile.objects.get(user=user ,name=name)
except:
return _error_response("Profile doesn't exist")
for p_v in profile.planprofileversion_set.all():
p_v.delete()
profile.delete()
return _success_response()
else:
return _error_response("Action not recognized")
if request.method == "GET":
return _get_not_allowed()
def get_top_reviews(request):
# time_start = time.time()
reviews = CourseUser.objects.annotate(length=Length("text")).filter(Q(length__gt=45) & Q(take="taken"))
if reviews.count() == 0:
return _success_response({"reviews":[]})
tot = sum([review.length for review in reviews])
reviews_prob = [review.length * 1.0 / tot for review in reviews]
K = 10
reviews = np.random.choice(reviews, K if K < len(reviews_prob) else len(reviews_prob), False, reviews_prob)
reviews = [get_json_of_review(review) for review in reviews]
# print("---------------get top reviews time--------------", time.time() - time_start)
return _success_response({
"reviews":reviews,
})
def get_match_header(request):
following = Follow.objects.following(request.user)
flw_ret = []
for flw in following:
if flw.profile.picture:
picture_url = flw.profile.picture.url
else:
picture_url = settings.STATIC_URL + "css/images/brand.jpg"
new_flw = {
"pk": flw.pk,
"picture": picture_url,
"user_url": "/users/" + flw.username + "/",
"first_name": flw.first_name,
"last_name": flw.last_name,
}
flw_ret.append(new_flw)
return _success_response({
"user": {
"first_name": request.user.first_name,
"last_name": request.user.last_name,
"role": request.user.profile.role,
},
"profile_urls": {
"profile":
reverse('profile', args=[request.user.username]),
"update_profile":
reverse('update_profile', args=[request.user.username]),
},
"following": flw_ret,
})
def get_instructor(request):
instructor_pk = request.GET.get("instructor_pk")
instructor = get_object_or_404(Instructor, pk=instructor_pk)
cs_instr_query = CourseInstructor.objects.filter(instructor=instructor)
all_courses = {}
for cs_instr in cs_instr_query:
tmp_course_number = cs_instr.course.mnemonic + cs_instr.course.number
if tmp_course_number not in all_courses:
all_courses[tmp_course_number] = {
"course_pk":cs_instr.course.pk,
"mnemonic":cs_instr.course.mnemonic,
"number":cs_instr.course.number,
"title":cs_instr.course.title,
"rating":get_rating_of_instructor_with_course(instructor, cs_instr.course)[0],
"semesters":[]
}
if cs_instr.semester not in all_courses[tmp_course_number]["semesters"]:
all_courses[tmp_course_number]["semesters"].append(cs_instr.semester)
tmp_rating, tmp_counter = get_rating_of_instructor(instructor)
return _success_response({
"name":instructor.__str__(),
"rating":tmp_rating,
"rating_counter":tmp_counter,
"rating_users_count":sum(tmp_counter),
"courses":all_courses,
})
def choose_role(request):
if request.method == "POST":
post = json.loads(request.body)
tmp_role = post.get("role")
if tmp_role == "Mentor" and request.user.profile.role == "":
dt = datetime.datetime.strptime(settings.HMP_CHECK_TIME,
'%Y-%m-%d')
user_review_num = request.user.courseuser_set.annotate(
length=Length("text")).filter(length__gt=15,
date__gt=dt).count()
if user_review_num < 3:
return _error_response(
"You don't have enough course comments.")
request.user.profile.role = "Mentor"
request.user.save()
elif tmp_role == "Mentee" and request.user.profile.role == "":
# return _error_response("Mentee registration not yet started.")
request.user.profile.role = "Mentee"
request.user.save()
else:
return _error_response("Unknown Reason")
return _success_response({
"role": request.user.profile.role,
})
if request.method == "GET":
return _get_not_allowed()
def submit_review(request):
if request.method == "POST":
post = json.loads(request.body)
text, rating_course, rating_instructor = post["text"], post["rating_course"], post["rating_instructor"]
course_instructor_pk = post["course_instructor_pk"]
if len(text.strip()) == 0 or rating_course == 0 or rating_instructor == 0:
return _error_response()
course_instructor = get_object_or_404(CourseInstructor, pk=course_instructor_pk)
cs_user_query = CourseUser.objects.filter(course=course_instructor.course, user=request.user)
if cs_user_query.first() != None:
cs_user = cs_user_query.first()
cs_user.text = text
cs_user.instructor = course_instructor.instructor
cs_user.take = "taken"
cs_user.rating_course = rating_course
cs_user.rating_instructor = rating_instructor
cs_user.course_instructor = course_instructor
cs_user.save()
else:
CourseUser.objects.create(course=course_instructor.course,
user=request.user,
instructor=course_instructor.instructor,
course_instructor=course_instructor,
text=text,
take="taken",
rating_course=rating_course,
rating_instructor=rating_instructor)
return _success_response()
if request.method == "GET":
return _get_not_allowed()
def edit_user(request):
if request.method == "POST":
username = request.POST.get("username")
if not username:
return _error_response("No username provided")
user = User.objects.filter(username=username).first()
if not user:
return _error_response("User does not exist.")
if user != request.user:
return _error_response("You can't edit other people's profile.")
profile_form = ProfileNewForm(request.POST,
request.FILES,
instance=user.profile)
user_form = UserForm(request.POST, request.FILES, instance=user)
if profile_form.is_valid() and user_form.is_valid():
# print("profile Form cleaned data", profile_form.cleaned_data)
# print("user Form cleaned data", user_form.cleaned_data)
profile_form.save()
user_form.save()
return _success_response()
else:
print("User Edit Error:", user_form.errors)
print("Profile Edit Error:", profile_form.errors)
if request.method == "GET":
return _get_not_allowed()
def get_roll_result(request):
date = request.GET.get("date")
tot_winners = int(request.GET.get("tot_winners"))
dt = datetime.datetime.strptime(date, '%Y-%m-%d')
users = []
for user in User.objects.all():
user_review_num = user.courseuser_set.annotate(length=Length("text")).filter(length__gt=15, date__gt=dt).count()
if user_review_num > 0 and user.username != "admin":
users.append({
"pk":user.pk,
"username":user.username,
"name":user.first_name + " " + user.last_name,
"reviews":user_review_num,
})
random.shuffle(users)
total_num = sum([u["reviews"] for u in users])
num_try, MAX_TRY = 0, 1000
result = []
while len(result) != tot_winners and num_try < MAX_TRY:
num_try += 1
result = []
lottery = sorted([random.randint(0, total_num - 1) for i in range(tot_winners)])
pointer = 0
left, right = 0, users[0]["reviews"] - 1
for i, user in enumerate(users):
if lottery[pointer] >= left and lottery[pointer] <= right:
result.append(user)
pointer += 1
if i == len(users) - 1 or pointer >= tot_winners:
break
left = right + 1
right = right + users[i + 1]["reviews"]
return _success_response({
"users":result
})
def get_user_match_header(request):
return _success_response({
"user": {
"first_name": request.user.first_name,
"last_name": request.user.last_name,
"role": request.user.profile.role,
}
})
def get_all_and_user_skills(request):
return _success_response({
"all_skills":
skills_as_dict(Skill.objects.all().exclude(type="Custom").exclude(
users=request.user),
empty_list=True),
"user_skills":
skills_as_dict(request.user.skill_set.all(), empty_list=True),
})
def get_all_users_roommate(request):
users = sorted(User.objects.filter(profile__rm=True).exclude(
username="******").exclude(profile__role=""),
key=lambda x: random.random())
return _success_response({
"users": [user_json(user, request) for user in users],
"request_user":
user_json(request.user, request),
})
def report_bug(request):
if request.method == "POST":
post = json.loads(request.body)
title, text = post.get("title"), post.get("text")
if len(title) > 0 and len(text) > 0:
Bug.objects.create(user=request.user, title=title, text=text)
return _success_response()
else:
return _error_response("Missing title or text field")
return _error_response("Get method not allowed")
def get_user_hmp_header(request):
return _success_response({
"user":{
"first_name":request.user.first_name,
"last_name":request.user.last_name,
"role":request.user.profile.role,
"num_reviews":request.user.courseuser_set.annotate(length=Length("text")).filter(length__gt=15).count(),
},
"taking_courses":get_take_courses(request.user, "taking")
})
def get_all_users(request):
start_time = time.time()
users = sorted(
User.objects.all().exclude(username="******").exclude(profile__role=""),
key=lambda x: random.random())
resp = {
"users": [user_json(user, request) for user in users],
"request_user": user_json(request.user, request),
}
print("DEBUG GET ALL USERS TIME:", time.time() - start_time)
return _success_response(resp)
def get_skill(request):
skill_id = request.GET.get("id")
try:
skill = Skill.objects.get(pk=skill_id)
users = skill.users.all()
return _success_response({
"skill":
skill_json(skill),
"users": [user_json(user, request) for user in users]
})
except:
return _error_response("Skill doesn't exist.")
def choose_roommate_role(request):
if request.method == "POST":
post = json.loads(request.body)
rm = post.get("rm")
if rm != True and rm != False:
return _error_response("Unknown Rm")
request.user.profile.rm = rm
request.user.save()
return _success_response({
"rm": request.user.profile.rm,
})
if request.method == "GET":
return _get_not_allowed()
def get_department(request):
start_time = time.time()
department_pk = request.GET.get("department_pk")
department = get_object_or_404(Department, pk=department_pk)
ret_courses = [get_detailed_json_of_course(cs, request.user, with_take=True) for cs in department.course_set.all().exclude(units="0")]
print("Time Spent:", time.time()-start_time)
return _success_response({
"department":{
"name":department.name,
"school":department.school,
},
"courses":ret_courses,
})
def get_basic_info(request):
info = {
"profile": reverse('profile', args=[request.user.username]),
"update_profile":reverse('update_profile', args=[request.user.username]),
}
return _success_response({
"all_info":info,
"user":{
"first_name":request.user.first_name,
"last_name":request.user.last_name,
"role":request.user.profile.role,
},
})
def get_profile(request):
username = request.GET.get('username')
if not username:
return _error_response()
editable = request.user.username == username
user = User.objects.filter(username=username).first()
if not user:
return _error_response()
return _success_response({
"editable":
editable,
"user":
user_json(user, request, personal_profile=True),
})
def get_recommendations(request):
year, semester, major = request.GET.get('year'), request.GET.get('semester'), request.GET.get('major')
users_pk = [sth.pk for sth in User.objects.filter(profile__major=major).exclude(username="******")]
if len(users_pk) == 0:
return _success_response({
"rcm_courses":[],
})
cs_users = CourseUser.objects.filter(user__pk__in=users_pk, take="taken")
final_cs_users = []
courses_dict = {}
for cs_user in cs_users:
if cs_user.user.profile.graduate_year:
tmp_year, tmp_semester = year_and_semester(cs_user.course_instructor.semester)
if tmp_year + 4 - int(cs_user.user.profile.graduate_year) == int(year) and tmp_semester == semester:
final_cs_users.append(cs_user)
for cs_user in final_cs_users:
if cs_user.course.pk not in courses_dict:
courses_dict[cs_user.course.pk] = 1
else:
courses_dict[cs_user.course.pk] += 1
courses = []
for pk, num in courses_dict.items():
tmp_course = get_object_or_404(Course, pk=pk)
courses.append({
"course_pk":pk,
"mnemonic":tmp_course.mnemonic,
"number":tmp_course.number,
"title":tmp_course.title,
"taken":num,
})
return _success_response({
"rcm_courses":courses,
})
def match_user(request):
if request.method == "POST":
post = json.loads(request.body)
user_1_pk, user_2_pk = post["user_1"], post["user_2"]
try:
user_1, user_2 = User.objects.get(pk=user_1_pk), User.objects.get(
pk=user_2_pk)
user_1.profile.matched = True
user_1.save()
user_2.profile.matched = True
user_2.save()
return _success_response()
except:
return _error_response("User doesn't exist")
if request.method == "GET":
return _get_not_allowed()
def get_major_options(request):
major = ""
semester = settings.CURRENT_SEMESTER[4:]
year = 0
majors = [{"text":item[0], "value":item[0]} for item in MAJOR_CHOICES]
if request.user.profile.major:
major = request.user.profile.major
if request.user.profile.graduate_year:
year = int(settings.CURRENT_YEAR) + 4 - int(request.user.profile.graduate_year)
return _success_response({
"major_options":majors,
"major":major,
"year":year,
"semester":semester,
})
def del_fav(request):
if request.method == "POST":
post = json.loads(request.body)
user_pk = post.get("user_pk")
try:
to_user = User.objects.get(pk=user_pk)
except:
return _error_response("User does not exist")
if Follow.objects.filter(follower=request.user,
followee=to_user).exists():
Follow.objects.remove_follower(follower=request.user,
followee=to_user)
return _success_response()
else:
return _error_response("Following relationship does not exist")
if request.method == "GET":
return _get_not_allowed()
def get_course_instructors(request):
course_pk, instructor_pk = request.GET.get("course_pk"), request.GET.get("instructor_pk")
course = get_object_or_404(Course, pk=course_pk)
instructor = get_object_or_404(Instructor, pk=instructor_pk)
course_instructor_relations = []
course_instructor_query = CourseInstructor.objects.filter(course=course, instructor=instructor)
for course_instructor in course_instructor_query:
course_instructor_relations.append({
"course_instructor_pk":course_instructor.pk,
"semester":course_instructor.semester,
"topic":course_instructor.topic,
})
return _success_response({
"course_instructors":course_instructor_relations,
})
def get_top_review_users(request):
date = request.GET.get("date")
dt = datetime.datetime.strptime(date, '%Y-%m-%d')
users = []
for user in User.objects.all():
user_review_num = user.courseuser_set.annotate(length=Length("text")).filter(length__gt=15, date__gt=dt).count()
if user_review_num > 0:
users.append({
"pk":user.pk,
"username":user.username,
"name":user.first_name + " " + user.last_name,
"reviews":user_review_num,
})
users = sorted(users, key=lambda x:x["reviews"], reverse=True)
return _success_response({
"review_users":users,
})
def user_del_skill(request):
if request.method == "POST":
post = json.loads(request.body)
skill_id = post.get("id")
skill = Skill.objects.filter(pk=skill_id).first()
if not skill:
return _error_response("Skill doesn't exist")
skill_relation = SkillRelation.objects.filter(user=request.user,
skill=skill).first()
if skill_relation:
skill_relation.delete()
if skill.users.count() == 0 and skill.type == "Custom":
skill.delete()
return _success_response()
else:
return _error_response("You don't have this skill")
if request.method == "GET":
return _get_not_allowed()
def course_search_result(request):
query = request.GET.get("query")
query_time = request.GET.get("time")
search_course = js_boolean(request.GET.get('cs'))
search_instructor = js_boolean(request.GET.get('instr'))
if not query or not query_time:
return _error_response("Query or Time not provided")
search_queryset = course_and_instructor_retrieve(query, search_course, search_instructor)
course_result = []
for query in search_queryset:
if query[1] == "instructor":
course_result.append(get_json_of_instructor(query[0]))
if query[1] == "course":
course_result.append(get_json_of_course(query[0]))
return _success_response({
"course_result": course_result,
"time":query_time,
})
def get_follow_list(request):
following = Follow.objects.following(request.user)
flw_ret = []
for flw in following:
if flw.profile.picture:
picture_url = flw.profile.picture.url
else:
picture_url = settings.STATIC_URL + "css/images/brand.jpg"
new_flw = {
"pk": flw.pk,
"picture": picture_url,
"user_url": "/users/" + flw.username + "/",
"first_name": flw.first_name,
"last_name": flw.last_name,
}
flw_ret.append(new_flw)
return _success_response({
"following": flw_ret,
})
