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)
