def submit_elaboration(request, course_short_title): if not 'challenge_id' in request.POST: return HttpResponse("missing parameter challenge_id", status=400) challenge = Challenge.objects.get(id=request.POST['challenge_id']) if not challenge.currently_active: return HttpResponse("challenge is currently not active", status=400) user = request.user course = Course.get_or_raise_404(short_title=course_short_title) if not challenge.is_enabled_for_user(user): return HttpResponse("challenge not enabled for user", status=400) if challenge.is_final_challenge() and challenge.is_in_lock_period(user, course): return HttpResponse("user is currently locked", status=400) elaboration, created = Elaboration.objects.get_or_create(challenge=challenge, user=user) if elaboration.is_submitted(): return HttpResponse("elaboration already submitted", status=400) elaboration.elaboration_text = request.POST['elaboration_text'] # sanitze here elaboration.revised_elaboration_text = elaboration.elaboration_text if elaboration.elaboration_text or UploadFile.objects.filter(elaboration=elaboration).exists(): elaboration.submission_time = datetime.now() elaboration.save() plagcheck_elaboration(elaboration) return HttpResponse()
def missing_reviews(request, course_short_title=None): course = Course.get_or_raise_404(short_title=course_short_title) elaborations = Elaboration.get_missing_reviews(course) # sort elaborations by submission time if type(elaborations) == list: elaborations.sort(key=lambda elaboration: elaboration.submission_time) else: elaborations = elaborations.order_by("submission_time") # store selected elaborations in session request.session["elaborations"] = serializers.serialize("json", elaborations) request.session["selection"] = "missing_reviews" request.session["count"] = len(elaborations) return render_to_response( "evaluation.html", { "overview": render_to_string( "overview.html", {"elaborations": elaborations, "course": course}, RequestContext(request) ), "count_missing_reviews": request.session.get("count", "0"), "stabilosiert_missing_reviews": "stabilosiert", "selection": request.session["selection"], "course": course, }, context_instance=RequestContext(request), )
def questions(request, course_short_title=None): course = Course.get_or_raise_404(short_title=course_short_title) challenges = Challenge.get_questions(course) # store selected challenges in session request.session["challenges"] = serializers.serialize("json", challenges) # store selected elaborations in session elaborations = [] request.session["elaborations"] = elaborations request.session["selection"] = "questions" request.session["count"] = len(challenges) return render_to_response( "evaluation.html", { "challenges": challenges, "overview": render_to_string( "questions.html", {"challenges": challenges, "course": course}, RequestContext(request) ), "count_questions": request.session.get("count", "0"), "stabilosiert_questions": "stabilosiert", "selection": request.session["selection"], "course": course, }, context_instance=RequestContext(request), )
def complaints(request, course_short_title=None): course = Course.get_or_raise_404(short_title=course_short_title) elaborations = list(Elaboration.get_complaints(course)) # sort elaborations by last comment time elaborations.sort(key=lambda elaboration: elaboration.get_last_post_date()) # store selected elaborations in session request.session["elaborations"] = serializers.serialize("json", elaborations) request.session["selection"] = "complaints" request.session["count"] = len(elaborations) return render_to_response( "evaluation.html", { "overview": render_to_string( "overview.html", {"elaborations": elaborations, "course": course, "complaints": "true"}, RequestContext(request), ), "count_complaints": request.session.get("count", "0"), "stabilosiert_complaints": "stabilosiert", "selection": request.session["selection"], "course": course, }, context_instance=RequestContext(request), )
def create_context_challenge(request, course_short_title): data = {} course = Course.get_or_raise_404(short_title=course_short_title) data['course'] = course if 'id' in request.GET: try: challenge = Challenge.objects.get(pk=request.GET.get('id')) except: raise Http404 user = RequestContext(request)['user'] data['challenge'] = challenge data['review_questions'] = [] for review_question in ReviewQuestion.objects.filter(challenge=challenge, visible_to_author=True).order_by("order"): data['review_questions'].append(review_question.text) # Create the elaboration to be able to upload files immediately Elaboration.objects.get_or_create(challenge=challenge, user=user) if Elaboration.objects.filter(challenge=challenge, user=user).exists(): elaboration = Elaboration.objects.get(challenge=challenge, user=user) data['elaboration'] = elaboration data['accepted'] = elaboration.is_started() data['success'] = elaboration.get_success_reviews() data['nothing'] = elaboration.get_nothing_reviews() data['fail'] = elaboration.get_fail_reviews() if Evaluation.objects.filter(submission=elaboration).exists(): data['evaluation'] = Evaluation.objects.filter(submission=elaboration)[0] if challenge.is_final_challenge(): data['blocked'] = not challenge.is_enabled_for_user(user) if challenge.is_in_lock_period(RequestContext(request)['user'], course): data['lock'] = challenge.is_in_lock_period(RequestContext(request)['user'], course) return data
def api_new_issue(request, course_short_title): """ API callback to create a new issue. """ course = Course.get_or_raise_404(course_short_title) lanes = Lane.objects.all().filter(hidden=False).order_by('order') data = json.loads(request.body.decode('utf-8')) user = RequestContext(request)['user'] # You can't create an issue without a title, type or a body. if 'title' not in data or 'type' not in data or 'body' not in data: return HttpResponseForbidden() if len(lanes) == 0: return HttpResponseServerError issue = Issue( author=user, course=course, lane=lanes[0], type=data['type'], title=data['title'], body=data['body'], user_agent=request.META['HTTP_USER_AGENT'], ) issue.save() return JsonResponse(issue.get_serializable(request.user.is_staff))
def notifications(request, course_short_title=None): data = {} user = request.user course = Course.get_or_raise_404(course_short_title) # check if rss token was already generated, if not generate it FeedToken.get_or_create_token(user) if 'id' in request.GET: try: notification = Notification.objects.get(pk=request.GET['id']) if not notification.user == user: raise Http404 except: raise Http404 notification.read = True notification.save() if 'link' in request.GET: return redirect(request.GET['link']) return redirect('Notification:list', course_short_title=course_short_title) notifications = Notification.objects.filter(user=user, course=course).order_by('-creation_time') data['notifications'] = notifications data['course'] = course try: data['feed_token'] = FeedToken.objects.get(user=request.user) except FeedToken.DoesNotExist: data['feed_token'] = None return render_to_response('notifications.html', data, context_instance=RequestContext(request))
def livecast_new_slide(request, course_short_title=None): if not request.method == 'POST' or not request.POST['secret'] == SLIDE_SECRET: return HttpResponse('must post') try: now = datetime.datetime.now() course = Course.get_or_raise_404(course_short_title) if 'lecture_id' in request.POST: lecture = Lecture.objects.get(course=course, active=True, id=request.POST['lecture_id']) tags = '' else: if _livecast_now(course): lecture = Lecture.objects.get(start__lte=now, end__gte=now, course=course, active=True) tags = "" else: lecture = Lecture.objects.filter(end__gte=now, course=course, active=True).order_by('start')[0] tags = ".preparation" if 'pub_date' in request.POST: pub_date = datetime.datetime.fromtimestamp(int(request.POST['pub_date'])) else: pub_date = now slide = Slide(title=request.POST['title'], pub_date=pub_date, filename=request.POST['filename'], lecture=lecture, tags=tags) slide.save() return HttpResponse(str(slide.id)) except ValueError: return HttpResponse('time error') except (Course.DoesNotExist, Course.MultipleObjectsReturned): return HttpResponse('course error.') except (Lecture.DoesNotExist, Lecture.MultipleObjectsReturned, IndexError): return HttpResponse('lecture error.')
def challenges(request, course_short_title=None): data = {} course = Course.get_or_raise_404(short_title=course_short_title) data['course'] = course user = AuroraAuthenticationBackend.get_user(AuroraAuthenticationBackend(), request.user.id) data['user_enlisted_and_active'] = user.enlisted_and_active_for_course(course) course_stacks = Stack.objects.all().filter(course=course).order_by("chapter") # raise Exception(course_stacks) data['course_stacks'] = [] for stack in course_stacks: submitted = stack.get_final_challenge().submitted_by_user(user) submission_time = None currently_active = stack.currently_active() if submitted: submission_time = stack.get_final_challenge().get_elaboration(user).submission_time data['course_stacks'].append({ 'stack': stack, 'user_can_enter_final_challenge': user.can_enter_final_challenge(stack), 'submitted': submitted, 'submission_time': submission_time, 'currently_active': currently_active, 'status': stack.get_status_text(user), 'points': stack.get_points_earned(user), 'possible': stack.get_points_available(), 'is_started': stack.is_started(user), }) return render_to_response('challenges.html', data, context_instance=RequestContext(request))
def sort(request, course_short_title=None): course = Course.get_or_raise_404(short_title=course_short_title) elaborations = [] for serialized_elaboration in serializers.deserialize('json', request.session.get('elaborations', {})): elaborations.append(serialized_elaboration.object) if request.GET.get('data', '') == "date_asc": elaborations.sort(key=lambda elaboration: elaboration.submission_time) if request.GET.get('data', '') == "date_desc": elaborations.sort(key=lambda elaboration: elaboration.submission_time, reverse=True) if request.GET.get('data', '') == "elab_asc": elaborations.sort(key=lambda elaboration: elaboration.challenge.title) if request.GET.get('data', '') == "elab_desc": elaborations.sort(key=lambda elaboration: elaboration.challenge.title, reverse=True) if request.GET.get('data', '') == "post_asc": elaborations.sort(key=lambda elaboration: elaboration.get_last_post_date()) if request.GET.get('data', '') == "post_desc": elaborations.sort(key=lambda elaboration: elaboration.get_last_post_date(), reverse=True) # store selected elaborations in session request.session['elaborations'] = serializers.serialize('json', elaborations) request.session['count'] = len(elaborations) data = { 'overview_html': render_to_string('overview.html', {'elaborations': elaborations, 'course': course}, RequestContext(request)), 'menu_html': render_to_string('menu.html', { 'count_' + request.session.get('selection', ''): request.session.get('count', '0'), 'stabilosiert_' + request.session.get('selection', ''): 'stabilosiert', 'course': course, }, RequestContext(request)), 'selection': request.session['selection'] } return HttpResponse(json.dumps(data))
def plagcheck_suspicions(request, course_short_title=None): course = Course.get_or_raise_404(short_title=course_short_title) suspicion_list = Suspicion.suspicion_list_by_request(request, course) count = suspicion_list.count() context = { 'course': course, 'suspicions': suspicion_list, 'suspicion_states': SuspicionState.choices(), 'current_suspicion_state_filter': int(request.GET.get('state', -1)), 'suspicions_count': count, 'open_new_window': False, 'enable_state_filter': True, } request.session['selection'] = 'plagcheck_suspicions' request.session['count'] = count return render_to_response('evaluation.html', { 'overview': render_to_string('plagcheck_suspicions.html', context, RequestContext(request)), 'course': course, 'stabilosiert_plagcheck_suspicions': 'stabilosiert', 'count_plagcheck_suspicions': count, 'selection': request.session['selection'], }, context_instance=RequestContext(request))
def plagcheck_suspects(request, course_short_title=None): course = Course.get_or_raise_404(short_title=course_short_title) show_filtered = int(request.GET.get('show_filtered', 0)) if show_filtered is 1: suspect_list = Suspect.objects.all() else: suspect_list = Suspect.objects.exclude(state=SuspectState.AUTO_FILTERED.value) paginator = Paginator(suspect_list, 25) page = request.GET.get('page') try: suspects = paginator.page(page) except PageNotAnInteger: suspects = paginator.page(1) except EmptyPage: suspects = paginator.page(paginator.num_pages) context = { 'course': course, 'suspects': suspects, 'suspect_states': SuspectState.choices(), 'show_filtered': show_filtered, } return render_to_response('evaluation.html', { 'overview': render_to_string('plagcheck_suspects.html', context, RequestContext(request)), 'course': course, }, context_instance=RequestContext(request))
def back(request, course_short_title=None): selection = request.session.get('selection', 'error') course = Course.get_or_raise_404(short_title=course_short_title) if selection == "search": return HttpResponse() if selection == "missing_reviews": elaborations = Elaboration.get_missing_reviews(course) if selection == "top_level_tasks": elaborations = Elaboration.get_top_level_tasks(course) if selection == "non_adequate_work": elaborations = Elaboration.get_non_adequate_work(course) if selection == "complaints": elaborations = Elaboration.get_complaints(course) if selection == "awesome": elaborations = Elaboration.get_awesome(course) if selection == "evaluated_non_adequate_work": elaborations = Elaboration.get_evaluated_non_adequate_work(course) # update overview if type(elaborations) == list: elaborations.sort(key=lambda elaboration: elaboration.submission_time) else: elaborations = elaborations.order_by('submission_time') request.session['elaborations'] = serializers.serialize('json', elaborations) return evaluation(request, course_short_title)
def challenges(request, course_short_title=None): data = {} course = Course.get_or_raise_404(short_title=course_short_title) data['course'] = course user = RequestContext(request)['user'] course_stacks = Stack.objects.all().filter(course=course) # raise Exception(course_stacks) data['course_stacks'] = [] for stack in course_stacks: submitted = stack.get_final_challenge().submitted_by_user(user) submission_time = None currently_active = stack.currently_active() if submitted: print(submitted) submission_time = stack.get_final_challenge().get_elaboration(user).submission_time data['course_stacks'].append({ 'stack': stack, 'submitted': submitted, 'submission_time': submission_time, 'currently_active': currently_active, 'status': stack.get_status_text(user), 'points': stack.get_points_earned(user) }) return render_to_response('challenges.html', data, context_instance=RequestContext(request))
def create_context_myreview(request, course_short_title): data = {} if 'id' not in request.GET: return data user = AuroraAuthenticationBackend.get_user(AuroraAuthenticationBackend(), request.user.id) data['challenge'] = Challenge.objects.get(pk= request.GET.get('id')) challenge = Challenge.objects.get(pk= request.GET.get('id')) data['user_reviews'] = [] for review in challenge.get_reviews_written_by_user(user): review_data = {} review_data['review_id'] = review.id review_data['review'] = review review_data['extra_review_question_answer'] = review.extra_review_question_answer review_data['appraisal'] = review.get_appraisal_display() evaluation = ReviewEvaluation.objects.filter(review=review) review_data['evaluation'] = '' if evaluation: review_data['evaluation'] = evaluation[0].appraisal data['user_reviews'].append(review_data) data['course'] = Course.get_or_raise_404(course_short_title) return data
def submit_elaboration(request, course_short_title): if not 'challenge_id' in request.POST: raise Http404 challenge = Challenge.objects.get(id=request.POST['challenge_id']) if not challenge.currently_active: raise Http404 user = RequestContext(request)['user'] course = Course.get_or_raise_404(short_title=course_short_title) if not challenge.is_enabled_for_user(user): raise Http404 if challenge.is_final_challenge() and challenge.is_in_lock_period(user, course): raise Http404 elaboration, created = Elaboration.objects.get_or_create(challenge=challenge, user=user) if elaboration.is_submitted(): raise Http404 elaboration.elaboration_text = request.POST['elaboration_text'] # sanitze here elaboration.revised_elaboration_text = elaboration.elaboration_text if elaboration.elaboration_text or UploadFile.objects.filter(elaboration=elaboration).exists(): elaboration.submission_time = datetime.now() elaboration.save() return HttpResponse()
def plagcheck_suspicions(request, course_short_title=None): course = Course.get_or_raise_404(short_title=course_short_title) suspicion_list = Suspicion.objects.filter( state=SuspicionState.SUSPECTED.value, #suspect_doc__submission_time__range=(course.start_date, course.end_date), suspect_doc__submission_time__gt=course.start_date, ) count = suspicion_list.count() context = { 'course': course, 'suspicions': suspicion_list, 'suspicion_states': SuspicionState.choices(), 'suspicions_count': count, } request.session['selection'] = 'plagcheck_suspicions' request.session['count'] = count return render_to_response('evaluation.html', { 'overview': render_to_string('plagcheck_suspicions.html', context, RequestContext(request)), 'course': course, 'stabilosiert_plagcheck_suspicions': 'stabilosiert', 'count_plagcheck_suspicions': count, 'selection': request.session['selection'], }, context_instance=RequestContext(request))
def thread(request, course_short_title, thread_id): course = Course.get_or_raise_404(course_short_title) thread_object = get_object_or_404(Thread, pk=thread_id) if thread_object.course != course: raise Http404("Thread does not exist") user_group = UserGroup.objects.filter(group__thread=thread_object, user=request.user).first() if user_group: thread_object.filter_group_id = user_group.group_id else: return redirect('diskurs:choose_group', course_short_title=course_short_title, thread_id=thread_id) user_history = UserHistory.objects.filter(user=request.user, thread=thread_object).first() if not user_history: user_history = UserHistory() user_history.thread = thread_object user_history.user = request.user user_history.save() viewed_posts = user_history.userhistorypost_set.values_list('post_id', flat=True) for post in thread_object.filtered_first_post.filtered_post_set.all(): if post.id not in viewed_posts: user_history.add_post_id_to_history(post.id) return render(request, 'diskurs/thread.html', {'thread': thread_object, 'expanded_posts': [thread_object.filtered_first_post.id], 'last_post_id': thread_object.filtered_first_post.id, 'viewed_posts': viewed_posts, 'course': course})
def plagcheck_compare(request, course_short_title=None, suspicion_id=None): course = Course.get_or_raise_404(short_title=course_short_title) suspicion = Suspicion.objects.get(pk=suspicion_id) (prev_suspicion_id, next_suspicion_id) = suspicion.get_prev_next( state=SuspicionState.SUSPECTED.value, #suspect_doc__submission_time__range=(course.start_date, course.end_date), suspect_doc__submission_time__gt=course.start_date, ) context = { 'course': course, 'suspicion': suspicion, 'suspicion_states': SuspicionState.states(), 'suspicion_states_class': SuspicionState.__members__, 'next_suspicion_id': next_suspicion_id, 'prev_suspicion_id': prev_suspicion_id, 'similar_has_elaboration': suspicion.similar_doc.was_submitted_during(course), 'suspect_has_elaboration': suspicion.suspect_doc.was_submitted_during(course) } # number of suspicious documents suspicions_count = Suspicion.objects.filter(state=SuspicionState.SUSPECTED.value).count() return render_to_response('evaluation.html', { 'detail_html': render_to_string('plagcheck_compare.html', context, RequestContext(request)), 'course': course, 'stabilosiert_plagcheck_suspicions': 'stabilosiert', 'count_plagcheck_suspicions': suspicions_count, }, context_instance=RequestContext(request))
def final_evaluation_new(request, course_short_title=None): course = Course.get_or_raise_404(short_title=course_short_title) elaborations = Elaboration.get_final_evaluation_top_level_tasks(course) # sort elaborations by submission time if type(elaborations) == list: elaborations.sort(key=lambda elaboration: elaboration.submission_time) else: elaborations = elaborations.order_by('submission_time') # store selected elaborations in session request.session['elaborations'] = serializers.serialize( 'json', elaborations) request.session['selection'] = 'final_evaluation_new' request.session['final_evaluation_count'] = len(elaborations) return render_to_response('evaluation.html', {'overview': render_to_string('overview_new.html', {'elaborations': elaborations, 'course': course}, RequestContext(request)), 'count_final_evaluation_new': request.session.get('final_evaluation_count', '0'), 'stabilosiert_final_evaluation_new': 'stabilosiert', 'selection': request.session['selection'], 'course': course }, context_instance=RequestContext(request))
def similarities(request, course_short_title=None): course = Course.get_or_raise_404(short_title=course_short_title) elaboration_id = request.session.get('elaboration_id', '') doc = Document.get_doc_from_elaboration_id(elaboration_id) not_checked = False if doc: if Result.objects.filter(doc_id=doc.id).count() == 0: not_checked = True else: not_checked = True suspicion_list = Suspicion.suspicion_list_by_request(request, course)\ .filter(suspect_doc__elaboration_id=elaboration_id) count = suspicion_list.count() context = { 'not_checked': not_checked, 'course': course, 'suspicions': suspicion_list, 'suspicion_states': SuspicionState.choices(), 'current_suspicion_state_filter': int(request.GET.get('state', -1)), 'suspicions_count': count, 'enable_state_filter': False, 'open_new_window': True, } return render_to_response('plagcheck_suspicions.html', context, RequestContext(request))
def home(request, course_short_title=None): user = request.user course = Course.get_or_raise_404(course_short_title) data = get_points(request, user, course) data = create_stat_data(course,data) data['user_is_top_reviewer'] = False data['number_of_extra_reviews'] = user.number_of_extra_reviews(course) data['reviews_until_next_extra_point'] = user.number_of_reviews_until_next_extra_point(course) data['extra_points_earned_with_reviews'] = user.extra_points_earned_with_reviews(course) if user.is_top_reviewer(course): # data['number_of_extra_reviews'] = user.number_of_extra_reviews(course) # data['reviews_until_next_extra_point'] = user.number_of_reviews_until_next_extra_point(course) # data['extra_points_earned_with_reviews'] = user.extra_points_earned_with_reviews(course) data['user_is_top_reviewer'] = True # Expensive function, therefor only execute if user is top reviewer data = get_extra_review_data(user, course, data) data['extra_points_earned_with_comments'] = user.extra_points_earned_with_comments(course) data['extra_points_earned_by_rating_reviews'] = user.extra_points_earned_by_rating_reviews(course) data['total_extra_points_earned'] = user.total_extra_points_earned(course) faq_list = Faq.get_faqs(course_short_title) context = RequestContext(request, {'newsfeed': data['course'], 'faq_list': faq_list}) return render_to_response('home.html', data, context)
def plagcheck_compare(request, course_short_title=None, suspect_id=None): course = Course.get_or_raise_404(short_title=course_short_title) suspect = Suspect.objects.get(pk=suspect_id) docA = Elaboration.objects.get(pk=suspect.doc_id) docB = Elaboration.objects.get(pk=suspect.similar_to_id) table = difflib.HtmlDiff(wrapcolumn=70).make_table(docA.elaboration_text.splitlines(), docB.elaboration_text.splitlines()) show_filtered = int(request.GET.get('show_filtered', 0)) (prev_suspect_id, next_suspect_id) = suspect.get_prev_next(show_filtered) context = { 'course': course, 'diff_table': table, 'suspect': suspect, 'suspect_states': SuspectState.states(), 'next_suspect_id': next_suspect_id, 'prev_suspect_id': prev_suspect_id, } return render_to_response('evaluation.html', { 'overview': render_to_string('plagcheck_compare.html', context, RequestContext(request)), 'course': course }, context_instance=RequestContext(request))
def index(request, course_short_title): """ index renders a simple html page, adds the react frontend code and some initial data, so that users don't have to make additional request to see the issues. """ # Pass some values directly as js variables, so that the client doesn't # has to make additional requests. course = Course.get_or_raise_404(course_short_title) lanes = None if request.user.is_staff: lanes = Lane.objects.all().order_by('order') else: # Only staff is allowed to see hidden lanes. lanes = Lane.objects.filter(hidden=False).order_by('order') if len(lanes) == 0: return render(request, 'Feedback/empty.html', {'course': course}) # Separately get the issues from the last lane and all the others, since # the last lane is the archive lane, and we'll only get issues from the # last two weeks and show less information for them. last_lane = lanes[len(lanes) - 1] issues = Issue.objects.exclude(lane=last_lane) start_date = datetime.now() - timedelta(days=14) archived = Issue.objects.filter(lane=last_lane) \ .filter(post_date__range=(start_date, datetime.now())) issues = chain(issues, archived) lanes = list(map(lambda lane: lane.serializable, lanes)) issue_data = [] for issue in issues: # Filter out any security issues, if the current user is not the owner # or an admin. if issue.type != 'security' or issue.author == request.user \ or request.user.is_staff: data = issue.get_serializable(request.user.is_staff) issue_data.append(data) data = { 'lanes': lanes, 'issues': issue_data, 'current_user': { 'is_staff': request.user.is_staff, 'id': request.user.id, } } return render( request, 'Feedback/index.html', { 'course': course, 'data': json.dumps(data) } )
def awesome(request, course_short_title=None): course = Course.get_or_raise_404(short_title=course_short_title) selected_challenge = request.session.get('selected_challenge', 'task...') if selected_challenge != 'task...': selected_challenge = selected_challenge[:(selected_challenge.rindex('(') - 1)] challenge = Challenge.objects.get(title=selected_challenge, course=course) elaborations = Elaboration.get_awesome_challenge(course, challenge) else: elaborations = Elaboration.get_awesome(course) # sort elaborations by submission time if type(elaborations) == list: elaborations.sort(key=lambda elaboration: elaboration.submission_time) else: elaborations = elaborations.order_by('submission_time') # store selected elaborations in session request.session['elaborations'] = serializers.serialize('json', elaborations) request.session['selection'] = 'awesome' request.session['selected_challenge'] = 'task...' request.session['count'] = len(elaborations) return render_to_response('evaluation.html', {'overview': render_to_string('overview.html', {'elaborations': elaborations, 'course': course}, RequestContext(request)), 'count_awesome': request.session.get('count', '0'), 'selected_task': selected_challenge, 'stabilosiert_awesome': 'stabilosiert', 'selection': request.session['selection'], 'course': course }, context_instance=RequestContext(request))
def autocomplete_challenge(request, course_short_title=None): course = Course.get_or_raise_404(short_title=course_short_title) term = request.GET.get('term', '') challenges = Challenge.objects.all().filter(title__istartswith=term, course=course) titles = [challenge.title + ' (' + str(challenge.get_sub_elab_count()) + '/' + str(challenge.get_elab_count()) + ')' for challenge in challenges] response_data = json.dumps(titles, ensure_ascii=False) return HttpResponse(response_data, content_type='application/json; charset=utf-8')
def get_object(self, request, *args, **kwargs): feed = { 'user': FeedToken.get_user_by_token_or_raise_404(kwargs['token']), 'course': Course.get_or_raise_404(kwargs['course_short_title']) } return feed
def create_context_challenge(request, course_short_title): data = {} course = Course.get_or_raise_404(short_title=course_short_title) data['course'] = course if 'id' in request.GET: try: challenge = Challenge.objects.get(pk=request.GET.get('id')) except: raise Http404 user = AuroraAuthenticationBackend.get_user( AuroraAuthenticationBackend(), request.user.id) data['challenge'] = challenge data['review_questions'] = [] for review_question in ReviewQuestion.objects.filter( challenge=challenge, visible_to_author=True).order_by("order"): data['review_questions'].append(review_question.text) # Create of load Evaluation if Elaboration.objects.filter(challenge=challenge, user=user).exists(): elaborations = Elaboration.objects.filter( challenge=challenge, user=user).order_by("-creation_time") if len(elaborations) > 1: # TODO notify someone logger.error("Found multiple elaborations") elaboration = elaborations.first() else: elaboration = Elaboration.objects.create(challenge=challenge, user=user) data['elaboration'] = elaboration data['accepted'] = elaboration.is_started() data['success'] = elaboration.get_success_reviews() data['nothing'] = elaboration.get_nothing_reviews() data['fail'] = elaboration.get_fail_reviews() extra_review_question_present = len( elaboration.extra_review_question) > 0 data['extra_review_question_present'] = extra_review_question_present if Evaluation.objects.filter(submission=elaboration, submission_time__isnull=False).exists(): data['evaluation'] = Evaluation.objects.filter( submission=elaboration)[0] if challenge.is_final_challenge(): data['blocked'] = not challenge.is_enabled_for_user(user) if challenge.is_in_lock_period(request.user, course): data['lock'] = challenge.is_in_lock_period( request.user, course) # else: # context_stack = Stack.objects.get(pk=request.GET.get('id')) # data['blocked'] = context_stack.is_blocked(user) return data
def slide_stack(request, topic=None, slug=None, course_short_title=None): """ :param request: :param topic: defines the context. This is important for previous and next page functionality. :param slug: identifies the SlideStack to be displayed. :return: a view of all slides assigned to the SlideStack. """ this_ss = get_object_or_404(SlideStack, slug=slug) # check date if this_ss.pub_date > timezone.now(): raise Http404("No such slide collection exists, or is published yet") # create next and previous link prev = '' nxt = '' if topic != 'none': ind = -1 stop = False used_slide_stacks = list() for ss in SlideStack.objects.filter(course=Course.objects.get(short_title=course_short_title)): if topic.lower() in (x.lower() for x in ss.list_categories): used_slide_stacks.append(ss) if stop: break if ss.slug == slug: ind = len(used_slide_stacks) - 1 stop = True if ind > 0: prev = reverse("Slides:slidestack", kwargs={"topic": topic, "slug": used_slide_stacks[ind - 1].slug, "course_short_title": course_short_title}) if ind < len(used_slide_stacks) - 1: nxt = reverse("Slides:slidestack", kwargs={"topic": topic, "slug": used_slide_stacks[ind + 1].slug, "course_short_title": course_short_title}) # find all other topics containing this SlideStack other_topics = [] this_topic = ('','search results') for cat in this_ss.list_category_tuples: if topic != cat[0] + '_' + cat[1]: other_topics.append(cat) else: this_topic = cat context = { "slide_stack": this_ss, "other_topics": other_topics, "prev": prev, "nxt": nxt, "this_topic": this_topic, "course": Course.get_or_raise_404(course_short_title), } return render(request, "slide_stack.html", context)
def overview(request, course_short_title=None): course = Course.get_or_raise_404(short_title=course_short_title) elaboration = Elaboration.objects.get(pk=request.GET.get('elaboration_id')) user = elaboration.user stack = elaboration.challenge.get_stack() stack_challenges = stack.get_challenges() next_elaboration = None try: # elaborations = Elaboration.get_final_evaluation_top_level_tasks(course) | Elaboration.objects.filter(id=elaboration.id) # all_elaborations = list(elaborations.order_by('submission_time')) elaborations = [] for serialized_elaboration in serializers.deserialize('json', request.session.get('elaborations', {})): elaborations.append(serialized_elaboration.object) next_index = elaborations.index(elaboration) + 1 if next_index < len(elaborations): next_elaboration = elaborations[next_index] else: next_elaboration = None except ValueError: next_elaboration = None challenges = [] for challenge in stack_challenges: challenge_data = {} challenge_data['challenge'] = challenge challenge_data['final'] = challenge.is_final_challenge() elaboration = challenge.get_elaboration(user) challenge_data['elaboration'] = elaboration challenge_data['reviews'] = challenge.get_reviews_written_by_user(user) challenge_data['reveiced_reviews'] = Review.objects.filter(elaboration=elaboration, submission_time__isnull=False) challenges.append(challenge_data) data = {} data['course'] = course data['elaboration_user'] = user data['stack'] = stack data['challenges'] = challenges data['elaboration'] = elaboration data['next_elaboration'] = next_elaboration evaluation = None lock = False if Evaluation.objects.filter(submission=elaboration): evaluation = Evaluation.objects.get(submission=elaboration) if evaluation.tutor != request.user and not evaluation.is_older_15min(): lock = True data['evaluation'] = evaluation data['evaluation_locked'] = lock return render_to_response('evaluation_overview.html', data, context_instance=RequestContext(request))
def create_context_stack(request, course_short_title): data = {} if 'id' not in request.GET: return data user = RequestContext(request)['user'] context_stack = Stack.objects.get(pk=request.GET.get('id')) data['stack'] = context_stack data['stack_blocked'] = context_stack.is_blocked(user) stack_challenges = StackChallengeRelation.objects.all().filter(stack=context_stack) challenges_active = [] challenges_inactive = [] for stack_challenge in stack_challenges: challenge = stack_challenge.challenge # challenges are not enabled for the user should be inactive if not challenge.is_enabled_for_user(user): # except final challenges where the previous challenge has enough user reviews if not (challenge.is_final_challenge() and challenge.prerequisite.has_enough_user_reviews(user)): challenges_inactive.append(challenge) continue reviews = [] for review in challenge.get_reviews_written_by_user(user): reviews.append({ 'review': review, 'submitted': review.submission_time is not None }) for i in range(Challenge.reviews_per_challenge - len(reviews)): reviews.append({}) submitted = challenge.submitted_by_user(user) submission_time = None if submitted: submission_time = challenge.get_elaboration(user).submission_time challenge_active = { 'challenge': challenge, 'submitted': submitted, 'submission_time': submission_time, 'reviews': reviews, 'status': challenge.get_status_text(user) } elaboration = Elaboration.objects.filter(challenge=challenge, user=user) if elaboration: elaboration = elaboration[0] challenge_active['success'] = len(elaboration.get_success_reviews()) challenge_active['nothing'] = len(elaboration.get_nothing_reviews()) challenge_active['fail'] = len(elaboration.get_fail_reviews()) challenge_active['awesome'] = len(elaboration.get_awesome_reviews()) evaluation = elaboration.get_evaluation() if evaluation: challenge_active['points'] = evaluation.evaluation_points challenges_active.append(challenge_active) data['challenges_active'] = challenges_active data['challenges_inactive'] = challenges_inactive data['course'] = Course.get_or_raise_404(course_short_title) data['len'] = len(challenges_active) + len(challenges_inactive) return data
def index(request, course_short_title): course = Course.get_or_raise_404(course_short_title) if request.user.is_superuser: threads = Thread.objects.filter(course=course) else: threads = Thread.objects.filter(group__usergroup__user=request.user, course=course) return render(request, 'diskurs/index.html', {'threads': threads, 'course': course})
def load_reviews(request, course_short_title=None): course = Course.get_or_raise_404(short_title=course_short_title) if not 'elaboration_id' in request.GET: return False; elaboration = Elaboration.objects.get(pk=request.GET.get('elaboration_id', '')) reviews = Review.objects.filter(elaboration=elaboration, submission_time__isnull=False) return render_to_response('task.html', {'elaboration': elaboration, 'reviews': reviews, 'stack': 'stack', 'course':course}, RequestContext(request))
def read(request, course_short_title=None): user = request.user course = Course.get_or_raise_404(course_short_title) notifications = Notification.objects.filter(user=user, course=course) for notification in notifications: if not notification.user == user: raise Http404 notification.read = True notification.save() return HttpResponse()
def start(request, course_short_title=None): course = Course.get_or_raise_404(course_short_title) lectures = _get_contentbar_data(course) render_dict = { 'slidecasting_mode': 'start', 'course': course, 'lectures': lectures } return render_to_response('start.html', render_dict, context_instance=RequestContext(request))
def work(request, course_short_title): user = AuroraAuthenticationBackend.get_user(AuroraAuthenticationBackend(), request.user.id) course = Course.get_or_raise_404(course_short_title) data = get_points(request, user, course) data = create_stat_data(course, data) context = RequestContext(request, data) return render_to_response('work.html', data, context)
def home(request, course_short_title=None): if not request.user.is_authenticated(): return redirect(reverse('User:login', args=(course_short_title, ))) user = RequestContext(request)['user'] course = Course.get_or_raise_404(course_short_title) data = get_points(request, user, course) data = create_stat_data(course,data) context = RequestContext(request, {'newsfeed': data['course']}) return render_to_response('home.html', data, context)
def autocomplete_challenge(request, course_short_title=None): course = Course.get_or_raise_404(short_title=course_short_title) term = request.GET.get('term', '') challenges = Challenge.objects.all().filter(title__istartswith=term, course=course) titles = [ challenge.title + ' (' + str(challenge.get_sub_elab_count()) + '/' + str(challenge.get_elab_count()) + ')' for challenge in challenges ] response_data = json.dumps(titles, ensure_ascii=False) return HttpResponse(response_data, content_type='application/json; charset=utf-8')
def sort(request, course_short_title=None): course = Course.get_or_raise_404(short_title=course_short_title) elaborations = [] for serialized_elaboration in serializers.deserialize( 'json', request.session.get('elaborations', {})): elaborations.append(serialized_elaboration.object) if request.GET.get('data', '') == "date_asc": elaborations.sort(key=lambda elaboration: elaboration.submission_time) if request.GET.get('data', '') == "date_desc": elaborations.sort(key=lambda elaboration: elaboration.submission_time, reverse=True) if request.GET.get('data', '') == "elab_asc": elaborations.sort(key=lambda elaboration: elaboration.challenge.title) if request.GET.get('data', '') == "elab_desc": elaborations.sort(key=lambda elaboration: elaboration.challenge.title, reverse=True) if request.GET.get('data', '') == "post_asc": elaborations.sort( key=lambda elaboration: elaboration.get_last_post_date()) if request.GET.get('data', '') == "post_desc": elaborations.sort( key=lambda elaboration: elaboration.get_last_post_date(), reverse=True) # store selected elaborations in session request.session['elaborations'] = serializers.serialize( 'json', elaborations) request.session['count'] = len(elaborations) data = { 'overview_html': render_to_string('overview.html', { 'elaborations': elaborations, 'course': course }, RequestContext(request)), 'menu_html': render_to_string( 'menu.html', { 'count_' + request.session.get('selection', ''): request.session.get('count', '0'), 'stabilosiert_' + request.session.get('selection', ''): 'stabilosiert', 'course': course, }, RequestContext(request)), 'selection': request.session['selection'] } return HttpResponse(json.dumps(data))
def thread_group_post(request, course_short_title, thread_id, post_id, group_id): course = Course.get_or_raise_404(course_short_title) thread_object = get_object_or_404(Thread, pk=thread_id) if thread_object.course != course: raise Http404("Thread does not exist") if request.user.is_superuser: group = get_object_or_404(Group, pk=group_id) if group.thread_id != int(thread_id): return redirect('diskurs:choose_group', course_short_title=course_short_title, thread_id=thread_id) thread_object.filter_group_id = group_id else: user_group = UserGroup.objects.filter(group__thread=thread_object, user=request.user).first() if user_group: thread_object.filter_group_id = user_group.group_id else: return redirect('diskurs:choose_group', course_short_title=course_short_title, thread_id=thread_id) post = Post.objects.get(id=post_id) last_post_id = post.id expanded_posts = list() rendered_posts = list() expanded_posts.append(post.id) rendered_posts.extend(post.filtered_post_set.values_list('id', flat=True)) while post.parent_post is not None: post = post.parent_post expanded_posts.append(post.id) rendered_posts.extend(post.filtered_post_set.values_list('id', flat=True)) user_history = UserHistory.objects.filter(user=request.user, thread=thread_object).first() if not user_history: user_history = UserHistory() user_history.thread = thread_object user_history.user = request.user user_history.save() viewed_posts = user_history.userhistorypost_set.values_list('post_id', flat=True) for rendered_post_id in rendered_posts: if rendered_post_id not in viewed_posts: user_history.add_post_id_to_history(rendered_post_id) return render(request, 'diskurs/thread.html', {'thread': thread_object, 'expanded_posts': expanded_posts, 'last_post_id': last_post_id, 'viewed_posts': viewed_posts, 'course': course})
def slide_topics(request, topic=None, course_short_title=None): """ :param request: :param topic: the topic to be represented :return: shows all SlideStacks, which are assigned to the given topic. """ # search for all slideStacks assigned to the topic used_slide_stacks = list() for ss in SlideStack.objects.filter(course=Course.objects.get( short_title=course_short_title)): if topic.lower() in (x.lower() for x in ss.list_categories): used_slide_stacks.append(ss) # check date filter_future_dates(used_slide_stacks) complete_list = sort_list_by_id(used_slide_stacks) # create next and previous link structure = list() if course_short_title == 'gsi': structure = GsiStructure.structure elif course_short_title == 'hci': structure = HciStructure.structure tup = topic.split('_') prev = '' nxt = '' for lst in structure: if lst[0] == tup[0]: chapt = lst.pop(0) i = lst.index(tup[1]) if i > 0: prev = '../' + chapt + '_' + lst[i - 1] if len(lst) > i + 1: nxt = '../' + chapt + '_' + lst[i + 1] lst.insert(0, chapt) context = { "title": tup[1], "section": tup[0], "used_slide_stacks": complete_list, "prev": prev, "nxt": nxt, "top": topic, "course": Course.get_or_raise_404(course_short_title), } return render(request, "slide_topics.html", context)
def livecast_update_slide(request, course_short_title=None, client_timestamp=None): course = Course.get_or_raise_404(course_short_title) client_time = datetime.datetime.fromtimestamp(int(client_timestamp)) slides = Slide.objects.filter(lecture__course=course, lecture__active=True, pub_date__gte=client_time) if slides.count() > 0: json_response = {'update': True, 'slide_id': slides.reverse()[0].id} else: json_response = {'update': False} json_response.update({'last_update': int(time.time())}) return HttpResponse(json.dumps(json_response), content_type='application/javascript')
def choose_group_set(request, course_short_title, thread_id, group_id): course = Course.get_or_raise_404(course_short_title) group_object = get_object_or_404(Group, pk=group_id) if group_object.thread.course != course: raise Http404("Thread does not exist") if group_object.thread_id == int(thread_id): if request.user.is_superuser: return redirect('diskurs:thread_group', course_short_title=course_short_title, thread_id=thread_id, group_id=group_id) return redirect('diskurs:choose_group', course_short_title=course_short_title, thread_id=thread_id) return redirect('diskurs:thread', course_short_title=course_short_title, thread_id=thread_id)
def search(request, course_short_title=None): course = Course.get_or_raise_404(short_title=course_short_title) selected_challenge = request.POST['selected_challenge'] selected_user = request.POST['selected_user'].split()[0] selected_tag = request.POST['selected_tag'] challenges = [] if (selected_challenge != 'task...'): challenges = Challenge.objects.filter(title=selected_challenge[:( request.POST['selected_challenge'].rindex('(') - 1)], course=course) else: challenges = Challenge.objects.filter(course=course) user = [] if (selected_user != 'user...'): user = AuroraUser.objects.filter(username=selected_user) request.session['display_points'] = "true" else: user = AuroraUser.objects.all() request.session['display_points'] = "false" if (selected_tag != 'tag...'): aurorauser_ct = ContentType.objects.get_for_model(AuroraUser) tagged_items = TaggedItem.objects.filter(content_type=aurorauser_ct, tag__name=selected_tag) tagged_user_ids = [] for ti in tagged_items: if not tagged_user_ids.__contains__(ti.content_object): tagged_user_ids.append(ti.content_object.id) tagged_user = AuroraUser.objects.filter(id__in=tagged_user_ids) user = user & tagged_user elaborations = [] if Elaboration.search(challenges, user): elaborations = list(Elaboration.search(challenges, user)) # store selected elaborations in session request.session['elaborations'] = serializers.serialize( 'json', elaborations) request.session['selection'] = 'search' request.session['selected_challenge'] = selected_challenge request.session['selected_user'] = selected_user request.session['selected_tag'] = selected_tag return evaluation(request, course_short_title)
def slides(request, course_short_title=None): """ :param request: :return: a view of all categories and their assigned topics. """ data_structure = [] if course_short_title == 'gsi': data_structure = GsiDataStructure.data_structure elif course_short_title == 'hci': data_structure = HciDataStructure.data_structure print(timezone.now()) context = { "structure": data_structure, "course": Course.get_or_raise_404(course_short_title), } return render(request, "slides_overview.html", context)
def search_user(request, course_short_title=None): course = Course.get_or_raise_404(short_title=course_short_title) if request.GET: user = AuroraUser.objects.get(pk=request.GET['id']) elaborations = user.get_course_elaborations(course) # sort elaborations by submission time if type(elaborations) == list: elaborations.sort(key=lambda elaboration: elaboration.submission_time) else: elaborations = elaborations.order_by('submission_time') # store selected elaborations in session request.session['elaborations'] = serializers.serialize('json', elaborations) request.session['selection'] = 'search' return evaluation(request, course_short_title)
def create_context_challenge(request, course_short_title): data = {} course = Course.get_or_raise_404(short_title=course_short_title) data['course'] = course if 'id' in request.GET: try: challenge = Challenge.objects.get(pk=request.GET.get('id')) except: raise Http404 user = request.user data['challenge'] = challenge data['review_questions'] = [] for review_question in ReviewQuestion.objects.filter( challenge=challenge, visible_to_author=True).order_by("order"): data['review_questions'].append(review_question.text) # Create the elaboration to be able to upload files immediately Elaboration.objects.get_or_create(challenge=challenge, user=user) if Elaboration.objects.filter(challenge=challenge, user=user).exists(): elaboration = Elaboration.objects.get(challenge=challenge, user=user) data['elaboration'] = elaboration data['accepted'] = elaboration.is_started() data['success'] = elaboration.get_success_reviews() data['nothing'] = elaboration.get_nothing_reviews() data['fail'] = elaboration.get_fail_reviews() if Evaluation.objects.filter(submission=elaboration).exists(): data['evaluation'] = Evaluation.objects.filter( submission=elaboration)[0] if challenge.is_final_challenge(): data['blocked'] = not challenge.is_enabled_for_user(user) if challenge.is_in_lock_period(request.user, course): data['lock'] = challenge.is_in_lock_period( request.user, course) # else: # context_stack = Stack.objects.get(pk=request.GET.get('id')) # data['blocked'] = context_stack.is_blocked(user) return data
def livecast_new_slide(request, course_short_title=None): if not request.method == 'POST' or not request.POST[ 'secret'] == SLIDE_SECRET: return HttpResponse('must post') try: now = datetime.datetime.now() course = Course.get_or_raise_404(course_short_title) if 'lecture_id' in request.POST: lecture = Lecture.objects.get(course=course, active=True, id=request.POST['lecture_id']) tags = '' else: if _livecast_now(course): lecture = Lecture.objects.get(start__lte=now, end__gte=now, course=course, active=True) tags = "" else: lecture = Lecture.objects.filter( end__gte=now, course=course, active=True).order_by('start')[0] tags = ".preparation" if 'pub_date' in request.POST: pub_date = datetime.datetime.fromtimestamp( int(request.POST['pub_date'])) else: pub_date = now slide = Slide(title=request.POST['title'], pub_date=pub_date, filename=request.POST['filename'], lecture=lecture, tags=tags) slide.save() return HttpResponse(str(slide.id)) except ValueError: return HttpResponse('time error') except (Course.DoesNotExist, Course.MultipleObjectsReturned): return HttpResponse('course error.') except (Lecture.DoesNotExist, Lecture.MultipleObjectsReturned, IndexError): return HttpResponse('lecture error.')
def challenges(request, course_short_title=None): data = {} course = Course.get_or_raise_404(short_title=course_short_title) data['course'] = course user = AuroraAuthenticationBackend.get_user(AuroraAuthenticationBackend(), request.user.id) data['user_enlisted_and_active'] = user.enlisted_and_active_for_course( course) course_stacks = Stack.objects.all().filter( course=course).order_by("chapter") # raise Exception(course_stacks) data['course_stacks'] = [] for stack in course_stacks: submitted = stack.get_final_challenge().submitted_by_user(user) submission_time = None currently_active = stack.currently_active() if submitted: submission_time = stack.get_final_challenge().get_elaboration( user).submission_time data['course_stacks'].append({ 'stack': stack, 'user_can_enter_final_challenge': user.can_enter_final_challenge(stack), 'submitted': submitted, 'submission_time': submission_time, 'currently_active': currently_active, 'status': stack.get_status_text(user), 'points': stack.get_points_earned(user), 'possible': stack.get_points_available(), 'is_started': stack.is_started(user), }) return render_to_response('challenges.html', data, context_instance=RequestContext(request))
def profile(request, course_short_title): user = request.user course = Course.get_or_raise_404(course_short_title) feed_token = None try: feed_token = FeedToken.objects.get(user=user) except FeedToken.DoesNotExist: pass context = { 'user': user, 'course': course, 'feed_token': feed_token, } return render_to_response('profile.html', context, context_instance=RequestContext(request))
def awesome(request, course_short_title=None): course = Course.get_or_raise_404(short_title=course_short_title) selected_challenge = request.session.get('selected_challenge', 'task...') if selected_challenge != 'task...': selected_challenge = selected_challenge[:( selected_challenge.rindex('(') - 1)] challenge = Challenge.objects.get(title=selected_challenge, course=course) elaborations = Elaboration.get_awesome_challenge(course, challenge) else: elaborations = Elaboration.get_awesome(course) # sort elaborations by submission time if type(elaborations) == list: elaborations.sort(key=lambda elaboration: elaboration.submission_time) else: elaborations = elaborations.order_by('submission_time') # store selected elaborations in session request.session['elaborations'] = serializers.serialize( 'json', elaborations) request.session['selection'] = 'awesome' request.session['selected_challenge'] = 'task...' request.session['count'] = len(elaborations) return render_to_response('evaluation.html', { 'overview': render_to_string('overview.html', { 'elaborations': elaborations, 'course': course }, RequestContext(request)), 'count_awesome': request.session.get('count', '0'), 'selected_task': selected_challenge, 'stabilosiert_awesome': 'stabilosiert', 'selection': request.session['selection'], 'course': course }, context_instance=RequestContext(request))
def review_answer(request, course_short_title=None): course = Course.get_or_raise_404(short_title=course_short_title) data = request.body.decode(encoding='UTF-8') data = json.loads(data) user = RequestContext(request)['user'] answers = data['answers'] review = Review.objects.create(elaboration_id=request.session.get( 'elaboration_id', ''), reviewer_id=user.id) review.appraisal = data['appraisal'] review.submission_time = datetime.now() review.save() for answer in answers: question_id = answer['question_id'] text = answer['answer'] review_question = ReviewQuestion.objects.get(pk=question_id) ReviewAnswer(review=review, review_question=review_question, text=text).save() if review.appraisal == review.NOTHING: Notification.bad_review(review) else: Notification.enough_peer_reviews(review) # update overview elaborations = Elaboration.get_missing_reviews(course) if type(elaborations) == list: elaborations.sort(key=lambda elaboration: elaboration.submission_time) else: elaborations = elaborations.order_by('submission_time') request.session['elaborations'] = serializers.serialize( 'json', elaborations) if review.elaboration.is_reviewed_2times(): evaluation_url = reverse('Evaluation:home', args=[course_short_title]) else: evaluation_url = reverse('Evaluation:detail', args=[course_short_title])\ + "?elaboration_id=" + str(review.elaboration.id) return HttpResponse(evaluation_url)
def similarities(request, course_short_title=None): course = Course.get_or_raise_404(short_title=course_short_title) elaboration_id = request.session.get('elaboration_id', '') suspicion_list = Suspicion.suspicion_list_by_request(request, course)\ .filter(suspect_doc__elaboration_id=elaboration_id) count = suspicion_list.count() context = { 'course': course, 'suspicions': suspicion_list, 'suspicion_states': SuspicionState.choices(), 'current_suspicion_state_filter': int(request.GET.get('state', -1)), 'suspicions_count': count, 'enable_state_filter': False, 'open_new_window': True, } return render_to_response('plagcheck_suspicions.html', context, RequestContext(request))
def complaints(request, course_short_title=None): course = Course.get_or_raise_404(short_title=course_short_title) elaborations = list(Elaboration.get_complaints(course)) # sort elaborations by last comment time elaborations.sort(key=lambda elaboration: elaboration.get_last_post_date()) # store selected elaborations in session request.session['elaborations'] = serializers.serialize('json', elaborations) request.session['selection'] = 'complaints' request.session['count'] = len(elaborations) return render_to_response('evaluation.html', {'overview': render_to_string('overview.html', {'elaborations': elaborations, 'course': course, 'complaints': 'true'}, RequestContext(request)), 'count_complaints': request.session.get('count', '0'), 'stabilosiert_complaints': 'stabilosiert', 'selection': request.session['selection'], 'course': course }, context_instance=RequestContext(request))
def studio_marker(request, marker, course_short_title=None): course = Course.get_or_raise_404(course_short_title) user = request.user lectures = _get_contentbar_data(course) if marker == 'confusing': slides = Slide.objects.filter(confusing=user, lecture__course=course) elif marker == 'important': slides = Slide.objects.filter(important=user, lecture__course=course) elif marker == 'liked': slides = Slide.objects.filter(liked=user, lecture__course=course) else: raise Http404 slides = _cache_slide_markers(slides) render_dict = { 'slidecasting_mode': 'marked_slides', 'marker': marker, 'course': course } render_dict.update({'lectures': lectures, 'slides': slides, 'user': user}) return render_to_response('studio.html', render_dict, context_instance=RequestContext(request))
def login(request, course_short_title=None): data = { 'course': Course.get_or_raise_404(course_short_title), 'signin_url': reverse('User:signin', args=(course_short_title, )), 'next': reverse('home', args=(course_short_title, )), 'sso_uri': settings.SSO_URI } if 'next' in request.GET: # TODO: add next functionality return render_to_response('login.html', data, context_instance=RequestContext(request)) elif 'error_message' in request.GET: data.update({'error_message': request.GET['error_message']}) return render_to_response('login.html', data, context_instance=RequestContext(request)) else: return render_to_response('login.html', data, context_instance=RequestContext(request))
def studio_lecture(request, course_short_title=None, lecture_id=None): course = Course.get_or_raise_404(course_short_title) user = request.user lectures = _get_contentbar_data(course) lecture = get_object_or_404(Lecture, id=lecture_id, course=course, active=True) if _livecast_now(lecture): url = reverse('Slides:livecast', args=(course_short_title, lecture_id)) return redirect(url) slides = Slide.objects.filter(lecture=lecture) slides = _cache_slide_markers(slides) slides_preparation = slides.filter(tags__contains='.preparation') slides_preparation = _cache_slide_markers(slides_preparation) videoclip_url, videoclip_name = _get_videoclip_url_name(lecture) videoclip_chapters = _get_videoclip_chapters(lecture, slides, slides_preparation) render_dict = { 'slidecasting_mode': 'studio', 'course': course, 'lectures': lectures, 'lecture': lecture } render_dict.update({ 'slides': slides, 'slides_preparation': slides_preparation, 'user': user }) render_dict.update({ 'videoclip_name': videoclip_name, 'videoclip_url': videoclip_url, 'videoclip_chapters': videoclip_chapters }) return render_to_response('studio.html', render_dict, context_instance=RequestContext(request))
def questions(request, course_short_title=None): course = Course.get_or_raise_404(short_title=course_short_title) challenges = Challenge.get_questions(course) # store selected challenges in session request.session['challenges'] = serializers.serialize('json', challenges) # store selected elaborations in session elaborations = [] request.session['elaborations'] = elaborations request.session['selection'] = 'questions' request.session['count'] = len(challenges) return render_to_response('evaluation.html', {'challenges': challenges, 'overview': render_to_string('questions.html', {'challenges': challenges, 'course': course}, RequestContext(request)), 'count_questions': request.session.get('count', '0'), 'stabilosiert_questions': 'stabilosiert', 'selection': request.session['selection'], 'course': course }, context_instance=RequestContext(request))
def notifications(request, course_short_title=None): data = {} user = request.user course = Course.get_or_raise_404(course_short_title) # check if rss token was already generated, if not generate it FeedToken.get_or_create_token(user) if 'id' in request.GET: try: notification = Notification.objects.get(pk=request.GET['id']) if not notification.user == user: raise Http404 except: raise Http404 notification.read = True notification.save() if 'link' in request.GET: return redirect(request.GET['link']) return redirect('Notification:list', course_short_title=course_short_title) notifications = Notification.objects.filter( user=user, course=course).order_by('-creation_time') data['notifications'] = notifications data['course'] = course try: data['feed_token'] = FeedToken.objects.get(user=request.user) except FeedToken.DoesNotExist: data['feed_token'] = None return render_to_response('notifications.html', data, context_instance=RequestContext(request))
def choose_group(request, course_short_title, thread_id): course = Course.get_or_raise_404(course_short_title) thread_object = get_object_or_404(Thread, pk=thread_id) if thread_object.course != course: raise Http404("Thread does not exist") groups = Group.objects.filter(thread_id=thread_id).order_by('id') empty_group_id = 0 for group in groups: if group.usergroup_set.count() < thread_object.members_in_group: empty_group_id = group.id break if empty_group_id == 0: group = Group() group.thread_id = thread_id group.save() groups = Group.objects.filter(thread_id=thread_id).order_by('id') empty_group_id = groups.last().id if request.user.is_superuser: return render(request, 'diskurs/thread/choose_group.html', {'groups': groups, 'thread': thread_object, 'course': course}) if not UserGroup.objects.filter(group__thread_id=thread_id, user_id=request.user).exists(): user_group = UserGroup() user_group.group_id = empty_group_id user_group.user_id = request.user.id user_group.save() return redirect('diskurs:thread', course_short_title=course_short_title, thread_id=thread_id)