def catalog(request): """function catalog This function handles the view for the catalog page of the application. Args: request (HTTPRequest): A http request object created automatically by Django. Returns: HttpResponse: A generated http response object to the request depending on whether or not the user is authenticated. """ # get all lesson sets, display if request.method == 'POST': print("Attempting to open the lesson: ", request.POST) if user_auth(request): # search for lesson set if lesson_set_auth(request): print(request) return redirect("/tutor/tutor") else: print("lesson set auth returned false") return redirect("accounts:profile") else: return redirect("/accounts/settings") else: return render(request, "tutor/catalog.html", {'LessonSet': MainSet.objects.all()})
def edit_assignment(request): """function educator This function handles the POST request for editing/deleting an assignment Args: request (HTTPRequest): A http request object created automatically by Django. Returns: HttpResponse: A generated http response object to the request. """ if request.method != 'POST': return redirect("/educator/") # Get assignment try: assignment_id = request.POST.get('assignment_id', -1) assignment = Assignment.objects.get(id=assignment_id) except Assignment.DoesNotExist: # Assignment doesn't exist! return redirect('/educator/') # Is user valid? if user_auth(request): # Case 1: User is valid user_info = UserInformation.objects.get(user=User.objects.get( email=request.user.email)) # Does user instruct the class? if user_auth_inst(user_info, assignment.class_key): # Case 1a: User is educator of class # Handle assignment edit delete = request.POST.get('delete_assignment', False) end_date = request.POST.get('end_date', None) # Basically a do: while(False) loop while True: if delete is not False: # Delete the assignment assignment.delete() break if end_date is None: request.session['error'] = "You must supply a due date!" break end_date = date.fromisoformat(end_date) if end_date < assignment.start_date: request.session[ 'error'] = "Assignment must open before it closes!" break assignment.end_date = end_date assignment.save() break return redirect( reverse('educator:class-view', args=[assignment.class_key_id])) else: # Case 1b: User doesn't teach class return redirect("/educator/") else: # Case 2: User doesn't exist in table return redirect("/accounts/settings")
def completed(request, index): """function previous This function handles retrieving the prev lesson. Args: request (HTTPRequest): A http request object created automatically by Django. index (int): The index of the lesson to retrieve Returns: HttpResponse: A generated http response object to the request depending on whether or not the user is authenticated. """ if request.method == 'GET': if user_auth(request): current_user = UserInformation.objects.get(user=User.objects.get( email=request.user.email)) if not_complete(request): main_set = MainSet.objects.filter( set_name=current_user.current_main_set)[0] item = main_set.lessons.all()[0] for count, item in enumerate(main_set.lessons.all()): if count == index: break current_lesson = Lesson.objects.get(lesson_title=item.first_in_set) set_len = len(current_user.current_main_set.lessons.all()) print("set len: ", set_len) num_done = finished_lesson_count(current_user) # create an ordered set ordered_set = current_user.current_main_set.lessons.all() count2 = 0 for count2, item in enumerate( current_user.current_main_set.lessons.all()): if item == current_user.current_lesson_set: break if index <= count2: lesson_info = get_log_data(current_user, index) print("lesson info: ", index) return render( request, "tutor/tutor.html", { 'lesson': current_lesson, 'lesson_code': lesson_info[0], 'concept': current_lesson.lesson_concept.all(), 'referenceSet': current_lesson.reference_set.all(), 'currLessonNum': current_user.current_lesson_index, 'setLength': set_len, 'finished_count': num_done, 'orderedSet': ordered_set, 'mood': lesson_info[1], 'past': lesson_info[2], 'completedLessonNum': count2, 'review': current_lesson.correct_feedback, 'index': index }) return redirect("tutor:tutor") return redirect("accounts:profile")
def advance_parsons_lesson(request, assignmentID): if request.method == 'GET': if user_auth(request): current_user = UserInformation.objects.get(user=User.objects.get(email=request.user.email)) assignment = Assignment.objects.get(id=assignmentID) assignment.advance_user(current_user.id) return HttpResponse(status = 204)
def educator(request): """function educator This function handles the view for the educator page of the application. Args: request (HTTPRequest): A http request object created automatically by Django. Returns: HttpResponse: A generated http response object to the request. """ # Is user valid? if user_auth(request): current_user = UserInformation.objects.get(user=User.objects.get( email=request.user.email)) # Case 1: User is valid # Is user educator? if user_is_educator(current_user): # Case 1a: User is educator if request.method == 'POST': # Handle new class creation class_name = request.POST.get('class-name', None) if class_name is not None: # Get unique join code join_code = random.randrange(100000, 999999, 1) while True: try: Class.objects.get(join_code=join_code) join_code = random.randrange(100000, 999999, 1) except Class.DoesNotExist: break new_class = Class(class_name=class_name, join_code=join_code) new_class.save() new_relation = ClassMembership( user_id=current_user.id, class_taking_id=new_class.id, is_educator=True) new_relation.save() messages.info( request, "Successfully created " + class_name + ". Students can input the code '" + str(join_code) + "' to join it.") return redirect("/educator") # Return class view return render(request, "educator/educator.html", {'classes': get_classes_taught(current_user)}) else: # Case 1b: User doesn't exist in table return redirect("/accounts/settings") else: # Case 2: User not valid. Go to login return redirect("/accounts/settings")
def edit_class(request): """function educator This function handles the POST request for renaming/deleting a class Args: request (HTTPRequest): A http request object created automatically by Django. Returns: HttpResponse: A generated http response object to the request. """ if request.method != 'POST': return redirect("/educator/") # Get class try: class_id = request.POST.get('class_id', -1) class_to_edit = Class.objects.get(id=class_id) except Class.DoesNotExist: # Class doesn't exist! return redirect('/educator/') # Is user valid? if user_auth(request): # Case 1: User is valid user_info = UserInformation.objects.get(user=User.objects.get( email=request.user.email)) # Does user instruct the class? if user_auth_inst(user_info, class_id): # Case 1a: User is educator of class # Handle class edit delete = request.POST.get('delete_class', False) new_name = request.POST.get('new_name', None) # Basically a do: while(False) loop while True: if delete is not False: # Delete the class class_to_edit.delete() break if new_name is None: request.session['error'] = "You must supply a class name!" break class_to_edit.class_name = new_name class_to_edit.save() break return redirect(reverse('educator:main-view')) else: # Case 1b: User doesn't teach class return redirect("/educator/") else: # Case 2: User doesn't exist in table return redirect("/accounts/settings")
def grader(request): """function grader This function handles checking code sent by the JS. Args: request (HTTPRequest): A http request object created automatically by Django. Returns: JsonResponse: A JSON response informing the browser of the results and the user's current state """ # Case 1: We have received a POST request submitting code (needs a lot of work) if request.method == 'POST': # Case 1a: if the user exists if user_auth(request): data = json.loads(request.body.decode('utf-8')) current_user = UserInformation.objects.get(user=User.objects.get( email=request.user.email)) assignment = Assignment.objects.get(id=data['assignment']) current_lesson_set, _, current_lesson, _, is_alternate = assignment.get_user_lesson( current_user.id) # Get submitted answer. No 'Confirm', no spaces, each ends with a semicolon submitted_answer = re.findall("Confirm [^;]*;|ensures [^;]*;", data['code']) submitted_answer = ''.join(submitted_answer) status, lines, vcs, completion_time = asyncio.run( send_to_verifier(data['code'])) # Log data log_data(current_user, assignment, current_lesson_set, current_lesson, is_alternate, data, status, vcs, completion_time) if status == "success": # Update assignment progress # Can use return value from advance_user to communicate to browser that assignment is completed assignment.advance_user(current_user.id) return JsonResponse( browser_response(current_lesson, assignment, current_user, submitted_answer, status, lines, True, False)) else: # Activate alternate if needed changed = assignment.alternate_check(current_user.id, data['code']) return JsonResponse( browser_response(current_lesson, assignment, current_user, submitted_answer, status, lines, changed, changed)) return redirect("accounts:profile")
def assignment_auth(request, assignment_id=None): """function lesson_auth This function handles the auth logic for whether a student can take an assignment Args: request (HTTPRequest): A http request object created automatically by Django. assignment_id: An optional ID that can be input to check GET requests Returns: Boolean: A boolean to signal if the student is able to go into the assignment """ if tutor_helper.user_auth(request): if assignment_id is None: assignment_id = request.POST.get("assignment_id") # Do we have the assignment in the DB? if Assignment.objects.filter(id=assignment_id).exists(): print("HIT") assignment = Assignment.objects.get(id=assignment_id) current_user = UserInformation.objects.get(user=User.objects.get( email=request.user.email)) # Is the user already taking this assignment? if AssignmentProgress.objects.filter( assignment_key=assignment, user_info_key=current_user).exists(): print("old assignment") # Check that assignment hasn't been completed already current_lesson_set, _, current_lesson, _, _ = assignment.get_user_lesson( current_user.id) if current_lesson_set is None or current_lesson is None: print("Already completed!") return False return True else: # Is the user in the class for this assignment? if ClassMembership.objects.filter( user=current_user, class_taking=assignment.class_key).exists(): progress = AssignmentProgress(user_info_key=current_user, assignment_key=assignment) progress.save() print("starting new assignment") return True print("User not in the class for this assignment!") else: print("Assignment doesn't exist!") else: print("Bad user!") return False
def classes(request): """function classes This function handles the view for the classes page of the application. Args: request (HTTPRequest): A http request object created automatically by Django. Returns: HttpResponse: A generated http response object to the request depending on whether or not the user is authenticated. """ if user_auth(request): current_user = UserInformation.objects.get(user=User.objects.get( email=request.user.email)) if request.method == 'POST': # Handle class join class_code = request.POST.get('class-code', None) if class_code is not None: try: class_to_join = Class.objects.get(join_code=class_code) except Class.DoesNotExist: class_to_join = None if class_to_join is not None: if ClassMembership.objects.filter( user_id=current_user.id, class_taking_id=class_to_join.id).exists(): messages.error( request, "You are already in " + str(class_to_join) + "!") else: new_relation = ClassMembership( user_id=current_user.id, class_taking_id=class_to_join.id, is_educator=False) new_relation.save() messages.info( request, "Successfully added you to " + str(class_to_join)) else: messages.error(request, "Sorry, class code invalid!") else: messages.error(request, "Sorry, class code invalid!") return redirect("/tutor/classes") return render(request, "tutor/classes.html", {'classes': get_classes(current_user)}) else: return redirect("/accounts/settings")
def class_view(request, classID): """function class_view This function handles the view for the class page of the application. Args: request (HTTPRequest): A http request object created automatically by Django. classID (int): The ID of the class that's being viewed Returns: HttpResponse: A generated http response object to the request depending on whether or not the user is authenticated. """ if user_auth(request): if user_in_class_auth( UserInformation.objects.get(user=User.objects.get( email=request.user.email)), classID): class_to_show = Class.objects.get(id=classID) return render(request, "tutor/assignments_student.html", {'class': class_to_show}) else: return redirect("/tutor/classes") else: return redirect("/accounts/settings")
def completed(request, index): """function previous This function handles retrieving the prev lesson. Args: request (HTTPRequest): A http request object created automatically by Django. index (int): The index of the lesson to retrieve Returns: HttpResponse: A generated http response object to the request depending on whether or not the user is authenticated. """ if request.method == 'GET': if user_auth(request): current_user = UserInformation.objects.get(user=User.objects.get(email=request.user.email)) if not not_complete(request): current_set = current_user.completed_sets.lessons.all() else: current_set = current_user.current_lesson_set.lessons.all() current_lesson = Lesson.objects.get(lesson_index=index) set_len = current_set.filter(is_alternate=False).count() print(set_len) num_done = finished_lesson_count(current_user) if index <= current_user.completed_lesson_index: lesson_info = get_log_data(current_user, index) print("lesson info: ", index) return render(request, "tutor/tutor.html", {'lesson': current_lesson, 'lesson_code': lesson_info[0], 'concept': current_lesson.lesson_concept.all(), 'referenceSet': current_lesson.reference_set.all(), 'currLessonNum': current_user.current_lesson_index, 'setLength': set_len, 'finished_count': num_done, 'currSet': current_set, 'mood': lesson_info[1], 'past': lesson_info[2], 'completedLessonNum': current_user.completed_lesson_index, 'review': current_lesson.correct_feedback}) return redirect("tutor:tutor") return redirect("accounts:profile")
def tutor(request): """function tutor This function handles the view for the tutor page of the application. Args: request (HTTPRequest): A http request object created automatically by Django. Returns: HttpResponse: A generated http response object to the request depending on whether or not the user is authenticated. """ print(request) # Case 1: We have received a POST request submitting code (needs a lot of work) if request.method == 'POST': # Case 1a: if the user exists if user_auth(request): # submitted_json = json.loads(request.body.decode('utf-8')) # if success, return next lesson # if fail, do something # Case 1aa: if the user has not completed set current_user = UserInformation.objects.get(user=User.objects.get(email=request.user.email)) print(current_user.current_lesson_name) current_lesson = Lesson.objects.get(lesson_name=current_user.current_lesson_name) print('current_lesson: ', current_lesson) submitted_answer = reverse_mutate(json.loads(request.body.decode('utf-8'))['answer'].replace(" ", ""), get_inv_key()) print('submitted answer: ' + submitted_answer) #Need to include submitted_answer in log data because it has the original variables log_data(request, submitted_answer) status = json.loads(request.body.decode('utf-8'))['status'] print("status: ", status) if status == "success": current_user.completed_lesson_index = current_lesson.lesson_index if Lesson.objects.filter(lesson_name=current_lesson.correct).exists(): current_user.current_lesson_index = Lesson.objects.get( lesson_name=current_lesson.correct).lesson_index else: print("Lesson does not exist") print("completed index: ", current_user.completed_lesson_index) print("current index: ", current_user.current_lesson_index) if Lesson.objects.filter(lesson_index=current_user.current_lesson_index).exists(): curr_lesson = Lesson.objects.get(lesson_index=current_user.current_lesson_index) print('curr_lesson: ', current_lesson) current_user.current_lesson_name = curr_lesson.lesson_name current_user.save() if current_user.completed_lesson_index == current_user.current_lesson_index: current_user.completed_sets = current_user.current_lesson_set current_user.current_lesson_set = None current_user.save() print("in done: ", current_user.current_lesson_set) # print(feedback['type']) # goto = alternate_lesson_check(current_lesson, feedback['type']) # feedback.update({'newLessonIndex': str(Lesson.objects.get(lesson_name=goto.lesson_name).lesson_index)}) # feedback.update({'newLessonCode': Lesson.objects.get(lesson_name=goto.lesson_name).code.lesson_code}) # feedback.update({'newLessonEx': Lesson.objects.get(lesson_name=goto.lesson_name).reason.reasoning_type}) return JsonResponse(check_feedback(current_lesson, submitted_answer, status)) # Case 2: We have received a GET request requesting code elif request.method == 'GET': # Ensure user exists # Case 2a: if the user exists print(not_complete(request)) if user_auth(request) and not_complete(request): # Case 2aa: if the user has a current set current_user = UserInformation.objects.get(user=User.objects.get(email=request.user.email)) current_set = current_user.current_lesson_set.lessons.all() set_len = current_set.filter(is_alternate=False).count() print(set_len) num_done = finished_lesson_count(current_user) # Case 2aaa: if the current set has a lesson of index that the user is on, set to current lesson if Lesson.objects.filter(lesson_index=current_user.current_lesson_index).exists(): current_lesson = Lesson.objects.get(lesson_index=current_user.current_lesson_index) # check if mutatable then mutate: code_after_mutate = can_mutate(request) if current_lesson.reason.reasoning_type == 'MC' or current_lesson.reason.reasoning_type == 'Both': return render(request, "tutor/tutor.html", {'lesson': current_lesson, 'lesson_code': code_after_mutate, 'concept': current_lesson.lesson_concept.all(), 'referenceSet': current_lesson.reference_set.all(), 'reason': current_lesson.reason.reasoning_question, 'mc_set': current_lesson.reason.mc_set.all(), 'currLessonNum': current_user.current_lesson_index, 'completedLessonNum': current_user.completed_lesson_index, 'setLength': set_len, 'finished_count': num_done, 'currSet': current_set, 'mood': current_user.mood, 'review': 'none', 'screen_record': current_lesson.screen_record, 'audio_record': current_lesson.audio_record, 'audio_transcribe': current_lesson.audio_transcribe, 'user_email': request.user.email}) # Case 2aaab: if question is of type Text elif current_lesson.reason.reasoning_type == 'Text': return render(request, "tutor/tutor.html", {'lesson': current_lesson, 'lesson_code': code_after_mutate, 'concept': current_lesson.lesson_concept.all(), 'referenceSet': current_lesson.reference_set.all(), 'reason': current_lesson.reason.reasoning_question, 'currLessonNum': current_user.current_lesson_index, 'completedLessonNum': current_user.completed_lesson_index, 'setLength': set_len, 'finished_count': num_done, 'currSet': current_set, 'mood': current_user.mood, 'review': 'none', 'screen_record': current_lesson.screen_record, 'audio_record': current_lesson.audio_record, 'audio_transcribe': current_lesson.audio_transcribe, 'user_email': request.user.email}) # Case 2aaac: if question is of type none return render(request, "tutor/tutor.html", {'lesson': current_lesson, 'lesson_code': code_after_mutate, 'concept': current_lesson.lesson_concept.all(), 'referenceSet': current_lesson.reference_set.all(), 'currLessonNum': current_user.current_lesson_index, 'completedLessonNum': current_user.completed_lesson_index, 'setLength': set_len, 'finished_count': num_done, 'currSet': current_set, 'mood': current_user.mood, 'review': 'none', 'screen_record': current_lesson.screen_record, 'audio_record': current_lesson.audio_record, 'audio_transcribe': current_lesson.audio_transcribe, 'user_email': request.user.email}) return redirect("accounts:profile")
def class_view_educator(request, classID): """function educator This function handles the view for the educator page of the application. Args: request (HTTPRequest): A http request object created automatically by Django. classID (int): ID of the class requested Returns: HttpResponse: A generated http response object to the request. """ # Is user valid? if user_auth(request): # Case 1: User is valid user_info = UserInformation.objects.get(user=User.objects.get( email=request.user.email)) # Does user instruct the class? if user_auth_inst(user_info, classID): # Case 1a: User is educator of class if request.method == 'POST': # Handle assignment creation main_set = request.POST.get('main_set', None) start_date = date.fromisoformat( request.POST.get('start_date', date.today().isoformat())) end_date = request.POST.get('end_date', None) # Basically a do: while(False) loop while True: if main_set is None: messages.error(request, "You must select a main set!") break if end_date is None: messages.error(request, "You must supply a due date!") break end_date = date.fromisoformat(end_date) if end_date < start_date: messages.error( request, "Assignment must open before it closes!") break new_assignment = Assignment(class_key_id=classID, main_set_id=main_set, start_date=start_date, end_date=end_date) new_assignment.save() return redirect( reverse('educator:class-view', args=[classID])) # Error carried from POST endpoints if 'error' in request.session: error = request.session['error'] del request.session['error'] messages.error(request, error) return render( request, "educator/assignments_educator.html", { 'class': Class.objects.get(id=classID), 'main_sets': MainSet.objects.filter(show=True), 'today': date.today().isoformat() }) else: # Case 1b: User doesn't teach class return redirect("/educator/") else: # Case 2: User doesn't exist in table return redirect("/accounts/settings")
def promote_student(request): """function educator This function handles the POST request for making a student an educator Args: request (HTTPRequest): A http request object created automatically by Django. Returns: HttpResponse: A generated http response object to the request. """ if request.method != 'POST': return redirect("/educator/") # Get class try: class_id = request.POST.get('class_id', -1) Class.objects.get(id=class_id) except Class.DoesNotExist: # Class doesn't exist! return redirect('/educator/') # Is user valid? if user_auth(request): # Case 1: User is valid user_info = UserInformation.objects.get(user=User.objects.get( email=request.user.email)) # Does user instruct the class? if user_auth_inst(user_info, class_id): # Case 1a: User is educator of class # Handle promotion student_id = request.POST.get('student_id', None) # Basically a do: while(False) loop while True: if student_id is None: request.session['error'] = "Server error. Try again?" break try: membership = ClassMembership.objects.get( user_id=student_id, class_taking_id=class_id) except ClassMembership.DoesNotExist: request.session['error'] = "Server error. Try again?" break try: account = UserInformation.objects.get(id=student_id) except UserInformation.DoesNotExist: request.session['error'] = "Server error. Try again?" break account.user_educator = True membership.is_educator = True account.save() membership.save() break return redirect(reverse('educator:members', args=[class_id])) else: # Case 1b: User doesn't teach class return redirect("/educator/") else: # Case 2: User doesn't exist in table return redirect("/accounts/settings")
def tutor(request): """function tutor This function handles the view for the tutor page of the application. Args: request (HTTPRequest): A http request object created automatically by Django. Returns: HttpResponse: A generated http response object to the request depending on whether or not the user is authenticated. """ print(request) # Case 1: We have received a POST request submitting code (needs a lot of work) if request.method == 'POST': # Case 1a: if the user exists if user_auth(request): # submitted_json = json.loads(request.body.decode('utf-8')) # if success, return next lesson # if fail, do something # Case 1aa: if the user has not completed set current_user = UserInformation.objects.get(user=User.objects.get( email=request.user.email)) current_lesson = Lesson.objects.get( lesson_name=current_user.current_lesson_name) status = json.loads(request.body.decode('utf-8'))['status'] print("status: ", status) submitted_answer = json.loads( request.body.decode('utf-8'))['answer'].replace(" ", "") submitted_answer = reverse_mutate(submitted_answer) log_data(request) unlock_next = False if status == "success": log_lesson(request) main_set = MainSet.objects.filter( set_name=current_user.current_main_set)[0] print(main_set) # if they are correct in a alt lesson, find correct to send to print("current_lesson.is_alternate: ", current_lesson.is_alternate, " current_user.current_lesson_index: ", current_user.current_lesson_index) if current_lesson.is_alternate and current_user.current_lesson_index != 0: print(current_lesson.correct, "%%%%%%%%%%") current_user.current_lesson_name = Lesson.objects.get( lesson_name=current_lesson.correct).lesson_name index = 0 current_set = Lesson.objects.get( lesson_name=current_user.current_lesson_name) print("CURRENT LESSON NAME: ", current_set, " ***** ", current_user.current_lesson_set.lessons.all()) if current_set in current_user.current_lesson_set.lessons.all( ): print("PRINT LESSONS: ", current_user.current_lesson_set.lessons.all()) #if current_user.current_lesson_name in current_user.current_lesson_set.lessons.all(): for index, item in enumerate( current_user.current_lesson_set.lessons.all()): print(index, "&&&&&&&&&", item.lesson_name) if item.lesson_name == current_lesson.correct: break current_user.current_lesson_index = index else: for index, item in enumerate(main_set.lessons.all()): if item == current_user.current_lesson_set: break next_set = LessonSet.objects.get( set_name=main_set.lessons.all()[index + 1]) print("***************** ", next_set) current_user.current_lesson_set = next_set current_user.current_lesson_name = next_set.first_in_set.lesson_name current_user.current_lesson_index = 0 current_user.save() unlock_next = True return JsonResponse( check_feedback(current_lesson, submitted_answer, status, unlock_next)) # find the index of the next lesson set by enumerating query set of all sets for index, item in enumerate(main_set.lessons.all()): if item == current_user.current_lesson_set: break # return if last set to go through print("|||||||", index, "|||||||", len(main_set.lessons.all())) if index + 1 >= len(main_set.lessons.all()): current_user.completed_sets.add( current_user.current_main_set) current_user.current_lesson_set = None current_user.current_main_set = None current_user.save() unlock_next = True print("in done: ", current_user.current_lesson_set) return JsonResponse( check_feedback(current_lesson, submitted_answer, status, unlock_next)) # return render(request, "accounts:profile") next_set = LessonSet.objects.get( set_name=main_set.lessons.all()[index + 1]) current_user.current_lesson_set = next_set current_user.current_lesson_name = next_set.first_in_set.lesson_name current_user.save() # if a user is not successful and there are alternates available print(current_lesson.sub_lessons_available, "%%%%%%%%%%") if status != "success" and current_lesson.sub_lessons_available: lesson_type = check_type(current_lesson, submitted_answer, status) alt_lesson = alternate_lesson_check( current_lesson, lesson_type) # how to set this and render new page # check if we changed to an alternate if Lesson.objects.get( lesson_title=alt_lesson ).lesson_name != current_user.current_lesson_name: unlock_next = True current_user.current_lesson_name = Lesson.objects.get( lesson_title=alt_lesson).lesson_name for index, item in enumerate( current_user.current_lesson_set.lessons.all()): if item == alt_lesson: break current_user.current_lesson_index = index current_user.save() print("******* ", alt_lesson, " ", index) return JsonResponse( check_feedback(current_lesson, submitted_answer, status, unlock_next)) # Case 2: We have received a GET request requesting code elif request.method == 'GET': # Ensure user exists # Case 2a: if the user exists print("in the get") if user_auth(request) and not_complete(request): # Case 2aa: if the user has a current set current_user = UserInformation.objects.get(user=User.objects.get( email=request.user.email)) current_set = current_user.current_lesson_set.lessons.all() set_len = len(current_user.current_main_set.lessons.all()) print(set_len) num_done = finished_lesson_count(current_user) print("===============", num_done) # Case 2aaa: if the current set has a lesson of index that the user is on, set to current lesson if Lesson.objects.filter(lesson_title=current_set[ current_user.current_lesson_index]).exists(): current_lesson = Lesson.objects.get(lesson_title=current_set[ current_user.current_lesson_index]) print("in if 1 - Current lesson: ", current_lesson) # Just as we are altering the code here with mutate, this will pull the previous answer # to put in place for sub lessons. What identifiers do we need? current_lesson.code.lesson_code = can_mutate(current_lesson) current_lesson.code.lesson_code = replace_previous( current_user, current_lesson.code.lesson_code, current_lesson.is_alternate) # create an ordered set index = 0 for index, item in enumerate( current_user.current_main_set.lessons.all()): if item == current_user.current_lesson_set: break if current_lesson.reason.reasoning_type == 'MC' or current_lesson.reason.reasoning_type == 'Both': return render( request, "tutor/tutor.html", { 'lesson': current_lesson, 'lesson_code': current_lesson.code.lesson_code, 'concept': current_lesson.lesson_concept.all(), 'referenceSet': current_lesson.reference_set.all(), 'reason': current_lesson.reason.reasoning_question, 'mc_set': current_lesson.reason.mc_set.all(), 'currLessonNum': current_user.current_lesson_index, 'completedLessonNum': current_user.completed_lesson_index, 'setLength': set_len, 'finished_count': num_done, 'orderedSet': current_user.current_main_set.lessons.all(), 'mood': current_user.mood, 'review': 'none', 'screen_record': current_lesson.screen_record, 'audio_record': current_lesson.audio_record, 'audio_transcribe': current_lesson.audio_transcribe, 'user_email': request.user.email, 'index': index }) # Case 2aaab: if question is of type Text elif current_lesson.reason.reasoning_type == 'Text': return render( request, "tutor/tutor.html", { 'lesson': current_lesson, 'lesson_code': current_lesson.code.lesson_code, 'concept': current_lesson.lesson_concept.all(), 'referenceSet': current_lesson.reference_set.all(), 'reason': current_lesson.reason.reasoning_question, 'currLessonNum': current_user.current_lesson_index, 'completedLessonNum': current_user.completed_lesson_index, 'setLength': set_len, 'finished_count': num_done, 'orderedSet': current_user.current_main_set.lessons.all(), 'mood': current_user.mood, 'review': 'none', 'screen_record': current_lesson.screen_record, 'audio_record': current_lesson.audio_record, 'audio_transcribe': current_lesson.audio_transcribe, 'user_email': request.user.email, 'index': index }) # Case 2aaac: if question is of type none return render( request, "tutor/tutor.html", { 'lesson': current_lesson, 'lesson_code': current_lesson.code.lesson_code, 'concept': current_lesson.lesson_concept.all(), 'referenceSet': current_lesson.reference_set.all(), 'currLessonNum': current_user.current_lesson_index, 'completedLessonNum': current_user.completed_lesson_index, 'setLength': set_len, 'finished_count': num_done, 'orderedSet': current_user.current_main_set.lessons.all(), 'mood': current_user.mood, 'review': 'none', 'screen_record': current_lesson.screen_record, 'audio_record': current_lesson.audio_record, 'audio_transcribe': current_lesson.audio_transcribe, 'user_email': request.user.email, 'index': index }) return redirect("accounts:profile")