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, })