Exemple #1
0
    def __init__(self, *args, **kwargs):
        self.contribution = kwargs.pop('contribution')
        self.questionnaire = kwargs.pop('questionnaire')

        super().__init__(*args, **kwargs)

        for question in self.questionnaire.question_set.all():
            # generic arguments for all kinds of fields
            field_args = dict(label=question.text)

            if question.is_text_question:
                field = forms.CharField(required=False,
                                        widget=forms.Textarea(),
                                        **field_args)
            elif question.is_likert_question:
                field = forms.TypedChoiceField(widget=forms.RadioSelect(),
                                               choices=LIKERT_CHOICES,
                                               coerce=int,
                                               **field_args)
            elif question.is_grade_question:
                field = forms.TypedChoiceField(widget=forms.RadioSelect(),
                                               choices=GRADE_CHOICES,
                                               coerce=int,
                                               **field_args)

            identifier = make_form_identifier(self.contribution,
                                              self.questionnaire, question)
            self.fields[identifier] = field
Exemple #2
0
    def __init__(self, *args, **kwargs):
        self.contribution = kwargs.pop('contribution')
        self.questionnaire = kwargs.pop('questionnaire')

        super().__init__(*args, **kwargs)

        for question in self.questionnaire.question_set.all():
            # generic arguments for all kinds of fields
            field_args = dict(label=question.text)

            if question.is_text_question:
                field = forms.CharField(required=False, widget=forms.Textarea(),
                                        **field_args)
            elif question.is_likert_question:
                field = forms.TypedChoiceField(widget=forms.RadioSelect(),
                                               choices=LIKERT_CHOICES,
                                               coerce=int,
                                               **field_args)
            elif question.is_grade_question:
                field = forms.TypedChoiceField(widget=forms.RadioSelect(),
                                               choices=GRADE_CHOICES,
                                               coerce=int,
                                               **field_args)

            identifier = make_form_identifier(self.contribution,
                                              self.questionnaire,
                                              question)
            self.fields[identifier] = field
Exemple #3
0
def vote(request, course_id):
    # retrieve course and make sure that the user is allowed to vote
    course = get_object_or_404(Course, id=course_id)
    if not course.can_user_vote(request.user):
        raise PermissionDenied

    # prevent a user from voting on themselves.
    contributions_to_vote_on = course.contributions.exclude(contributor=request.user).all()
    form_groups = helper_create_voting_form_groups(request, contributions_to_vote_on)

    if not all(all(form.is_valid() for form in form_group) for form_group in form_groups.values()):
        errors_exist = any(helper_has_errors(form_group) for form_group in form_groups.values())

        course_form_group = form_groups.pop(course.general_contribution)

        contributor_form_groups = list((contribution.contributor, contribution.label, form_group, helper_has_errors(form_group)) for contribution, form_group in form_groups.items())

        template_data = dict(
            errors_exist=errors_exist,
            course_form_group=course_form_group,
            contributor_form_groups=contributor_form_groups,
            course=course,
            participants_warning=course.num_participants <= 5,
            preview=False)
        return render(request, "student_vote.html", template_data)

    # all forms are valid, begin vote operation
    with transaction.atomic():
        # add user to course.voters
        # not using course.voters.add(request.user) since it fails silently when done twice.
        # manually inserting like this gives us the 'created' return value and ensures at the database level that nobody votes twice.
        __, created = course.voters.through.objects.get_or_create(userprofile_id=request.user.pk, course_id=course.pk)
        if not created:  # vote already got recorded, bail out
            raise SuspiciousOperation("A second vote has been received shortly after the first one.")

        for contribution, form_group in form_groups.items():
            for questionnaire_form in form_group:
                questionnaire = questionnaire_form.questionnaire
                for question in questionnaire.question_set.all():
                    identifier = make_form_identifier(contribution, questionnaire, question)
                    value = questionnaire_form.cleaned_data.get(identifier)

                    if question.is_text_question:
                        if value:
                            question.answer_class.objects.create(
                                contribution=contribution,
                                question=question,
                                answer=value)
                    else:
                        if value != 6:
                            answer_counter, __ = question.answer_class.objects.get_or_create(contribution=contribution, question=question, answer=value)
                            answer_counter.add_vote()
                            answer_counter.save()

        course.course_evaluated.send(sender=Course, request=request, semester=course.semester)

    messages.success(request, _("Your vote was recorded."))
    return redirect('student:index')
Exemple #4
0
def vote(request, course_id):
    # retrieve course and make sure that the user is allowed to vote
    course = get_object_or_404(Course, id=course_id)
    if not course.can_user_vote(request.user):
        raise PermissionDenied

    # prevent a user from voting on themselves.
    contributions_to_vote_on = course.contributions.exclude(contributor=request.user).all()
    form_groups = helper_create_voting_form_groups(request, contributions_to_vote_on)

    if not all(all(form.is_valid() for form in form_group) for form_group in form_groups.values()):
        errors_exist = any(helper_has_errors(form_group) for form_group in form_groups.values())

        course_form_group = form_groups.pop(course.general_contribution)

        contributor_form_groups = list((contribution.contributor, contribution.label, form_group, helper_has_errors(form_group)) for contribution, form_group in form_groups.items())

        template_data = dict(
            errors_exist=errors_exist,
            course_form_group=course_form_group,
            contributor_form_groups=contributor_form_groups,
            course=course,
            participants_warning=course.num_participants <= 5,
            preview=False)
        return render(request, "student_vote.html", template_data)

    # all forms are valid, begin vote operation
    with transaction.atomic():
        for contribution, form_group in form_groups.items():
            for questionnaire_form in form_group:
                questionnaire = questionnaire_form.questionnaire
                for question in questionnaire.question_set.all():
                    identifier = make_form_identifier(contribution, questionnaire, question)
                    value = questionnaire_form.cleaned_data.get(identifier)

                    if question.is_text_question:
                        if value:
                            question.answer_class.objects.create(
                                contribution=contribution,
                                question=question,
                                answer=value)
                    else:
                        if value != 6:
                            answer_counter, __ = question.answer_class.objects.get_or_create(contribution=contribution, question=question, answer=value)
                            answer_counter.add_vote()
                            answer_counter.save()

        # remember that the user voted already
        course.voters.add(request.user)

        course.was_evaluated(request)

    messages.success(request, _("Your vote was recorded."))
    return redirect('student:index')
Exemple #5
0
def vote(request, course_id):
    # retrieve course and make sure that the user is allowed to vote
    course = get_object_or_404(Course, id=course_id)
    if not course.can_user_vote(request.user):
        raise PermissionDenied

    # prevent a user from voting on themselves.
    contributions_to_vote_on = course.contributions.exclude(contributor=request.user).all()
    form_groups = helper_create_voting_form_groups(request, contributions_to_vote_on)

    if not all(all(form.is_valid() for form in form_group) for form_group in form_groups.values()):
        errors_exist = any(helper_has_errors(form_group) for form_group in form_groups.values())

        course_form_group = form_groups.pop(course.general_contribution)

        contributor_form_groups = list((contribution.contributor, form_group, helper_has_errors(form_group)) for contribution, form_group in form_groups.items())

        template_data = dict(
                errors_exist=errors_exist,
                course_form_group=course_form_group,
                contributor_form_groups=contributor_form_groups,
                course=course,
                preview=False)
        return render(request, "student_vote.html", template_data)

    # all forms are valid, begin vote operation
    with transaction.atomic():
        for contribution, form_group in form_groups.items():
            for questionnaire_form in form_group:
                questionnaire = questionnaire_form.questionnaire
                for question in questionnaire.question_set.all():
                    identifier = make_form_identifier(contribution, questionnaire, question)
                    value = questionnaire_form.cleaned_data.get(identifier)

                    if type(value) in [str, unicode]:
                        value = value.strip()

                    if value == 6: # no answer
                        value = None

                    # store the answer if one was given
                    if value:
                        question.answer_class.objects.create(
                            contribution=contribution,
                            question=question,
                            answer=value)

        # remember that the user voted already
        course.voters.add(request.user)

        course.was_evaluated(request)

    messages.success(request, _("Your vote was recorded."))
    return redirect('evap.student.views.index')
Exemple #6
0
def vote(request, course_id):
    # retrieve course and make sure that the user is allowed to vote
    course = get_object_or_404(Course, id=course_id)
    if not course.can_user_vote(request.user):
        raise PermissionDenied

    form_groups = create_voting_form_groups(request, course.contributions.all())

    if not all(all(form.is_valid() for form in form_group.values()) for form_group in form_groups.values()):
        
        course_forms = form_groups[course.general_contribution].values()

        contributor_questionnaires, errors = create_contributor_questionnaires(form_groups.items())

        return render_to_response(
            "student_vote.html",
            dict(course_forms=course_forms,
                 contributor_questionnaires=contributor_questionnaires,
                 errors=errors,
                 course=course),
            context_instance=RequestContext(request))

    # all forms are valid
    # begin vote operation
    with transaction.atomic():
        for contribution, form_group in form_groups.items():
            for questionnaire, form in form_group.items():
                for question in questionnaire.question_set.all():
                    identifier = make_form_identifier(contribution, questionnaire, question)
                    value = form.cleaned_data.get(identifier)

                    if type(value) in [str, unicode]:
                        value = value.strip()

                    if value == 6: # no answer
                        value = None

                    # store the answer if one was given
                    if value:
                        question.answer_class.objects.create(
                            contribution=contribution,
                            question=question,
                            answer=value)

        # remember that the user voted already
        course.voters.add(request.user)

        course.was_evaluated(request)

    messages.success(request, _("Your vote was recorded."))
    return redirect('evap.student.views.index')
Exemple #7
0
def vote(request, course_id):
    # retrieve course and make sure that the user is allowed to vote
    course = get_object_or_404(Course, id=course_id)
    if not course.can_user_vote(request.user):
        raise PermissionDenied

    # build forms
    forms = SortedDict()
    for questionnaire, contribution in questionnaires_and_contributions(
            course):
        form = QuestionsForm(request.POST or None,
                             contribution=contribution,
                             questionnaire=questionnaire)
        forms[(contribution, questionnaire)] = form

    if all(form.is_valid() for form in forms.values()):
        # begin vote operation
        with transaction.commit_on_success():
            for (contribution, questionnaire), form in forms.items():
                for question in questionnaire.question_set.all():
                    identifier = make_form_identifier(contribution,
                                                      questionnaire, question)
                    value = form.cleaned_data.get(identifier)

                    if type(value) in [str, unicode]:
                        value = value.strip()

                    if value == 6:  #no answer
                        value = None

                    # store the answer if one was given
                    if value:
                        question.answer_class.objects.create(
                            contribution=contribution,
                            question=question,
                            answer=value)

            # remember that the user voted already
            course.voters.add(request.user)

        messages.add_message(request, messages.INFO,
                             _("Your vote was recorded."))
        return redirect('evap.student.views.index')
    else:
        return render_to_response("student_vote.html",
                                  dict(forms=forms.values(), course=course),
                                  context_instance=RequestContext(request))
Exemple #8
0
def vote(request, course_id):
    # retrieve course and make sure that the user is allowed to vote
    course = get_object_or_404(Course, id=course_id)
    if not course.can_user_vote(request.user):
        raise PermissionDenied

    # build forms
    forms = SortedDict()
    for questionnaire, contribution in questionnaires_and_contributions(course):
        form = QuestionsForm(request.POST or None, contribution=contribution, questionnaire=questionnaire)
        forms[(contribution, questionnaire)] = form

    if all(form.is_valid() for form in forms.values()):
        # begin vote operation
        with transaction.commit_on_success():
            for (contribution, questionnaire), form in forms.items():
                for question in questionnaire.question_set.all():
                    identifier = make_form_identifier(contribution, questionnaire, question)
                    value = form.cleaned_data.get(identifier)

                    if type(value) in [str, unicode]:
                        value = value.strip()

                    if value == 6: #no answer
                        value = None

                    # store the answer if one was given
                    if value:
                        question.answer_class.objects.create(
                            contribution=contribution,
                            question=question,
                            answer=value)

            # remember that the user voted already
            course.voters.add(request.user)

        messages.add_message(request, messages.INFO, _("Your vote was recorded."))
        return redirect('evap.student.views.index')
    else:
        return render_to_response(
            "student_vote.html",
            dict(forms=forms.values(),
                 course=course),
            context_instance=RequestContext(request))
Exemple #9
0
    def __init__(self, *args, **kwargs):
        self.assignment = kwargs.pop("assignment")
        self.questionnaire = kwargs.pop("questionnaire")

        super(QuestionsForm, self).__init__(*args, **kwargs)

        for question in self.questionnaire.question_set.all():
            # generic arguments for all kinds of fields
            field_args = dict(label=question.text)

            if question.is_text_question():
                field = forms.CharField(required=False, widget=forms.Textarea(), **field_args)
            elif question.is_grade_question():
                field = forms.TypedChoiceField(
                    widget=forms.RadioSelect(renderer=RadioFieldTableRenderer),
                    choices=GRADE_CHOICES,
                    coerce=coerce_grade,
                    **field_args
                )

            identifier = make_form_identifier(self.assignment, self.questionnaire, question)
            self.fields[identifier] = field
Exemple #10
0
    def __init__(self, *args, contribution, questionnaire, **kwargs):
        super().__init__(*args, **kwargs)
        self.questionnaire = questionnaire

        for question in self.questionnaire.question_set.all():
            # generic arguments for all kinds of fields
            field_args = dict(label=question.text)

            if question.is_text_question:
                field = forms.CharField(required=False, widget=forms.Textarea(),
                                        **field_args)
            elif question.is_likert_question:
                field = forms.TypedChoiceField(widget=forms.RadioSelect(),
                                               choices=LIKERT_CHOICES,
                                               coerce=int,
                                               **field_args)
            elif question.is_grade_question:
                field = forms.TypedChoiceField(widget=forms.RadioSelect(),
                                               choices=GRADE_CHOICES,
                                               coerce=int,
                                               **field_args)
            elif question.is_positive_yes_no_question:
                field = forms.TypedChoiceField(widget=forms.RadioSelect(),
                                               choices=POSITIVE_YES_NO_CHOICES,
                                               coerce=int,
                                               **field_args)
            elif question.is_negative_yes_no_question:
                field = forms.TypedChoiceField(widget=forms.RadioSelect(),
                                               choices=NEGATIVE_YES_NO_CHOICES,
                                               coerce=int,
                                               **field_args)

            identifier = make_form_identifier(contribution,
                                              questionnaire,
                                              question)
            self.fields[identifier] = field
Exemple #11
0
    def __init__(self, *args, contribution, questionnaire, **kwargs):
        super().__init__(*args, **kwargs)
        self.questionnaire = questionnaire

        for question in self.questionnaire.question_set.all():
            # generic arguments for all kinds of fields
            field_args = dict(label=question.text)

            if question.is_text_question:
                field = forms.CharField(required=False,
                                        widget=forms.Textarea(),
                                        **field_args)
            elif question.is_likert_question:
                field = forms.TypedChoiceField(widget=forms.RadioSelect(),
                                               choices=LIKERT_CHOICES,
                                               coerce=int,
                                               **field_args)
            elif question.is_grade_question:
                field = forms.TypedChoiceField(widget=forms.RadioSelect(),
                                               choices=GRADE_CHOICES,
                                               coerce=int,
                                               **field_args)
            elif question.is_positive_yes_no_question:
                field = forms.TypedChoiceField(widget=forms.RadioSelect(),
                                               choices=POSITIVE_YES_NO_CHOICES,
                                               coerce=int,
                                               **field_args)
            elif question.is_negative_yes_no_question:
                field = forms.TypedChoiceField(widget=forms.RadioSelect(),
                                               choices=NEGATIVE_YES_NO_CHOICES,
                                               coerce=int,
                                               **field_args)

            identifier = make_form_identifier(contribution, questionnaire,
                                              question)
            self.fields[identifier] = field
Exemple #12
0
def vote(request, course_id):
    # retrieve course and make sure that the user is allowed to vote
    course = get_object_or_404(Course, id=course_id)
    if not course.can_user_vote(request.user):
        raise PermissionDenied

    # build forms
    form_group = {}
    contributors_with_questionnaires = questionnaires_and_contributions_by_contributor(course)
    for contributor in contributors_with_questionnaires:
        for questionnaire, contribution in contributors_with_questionnaires[contributor]:
            form = QuestionsForm(request.POST or None, contribution=contribution, questionnaire=questionnaire)
            if form.contribution.contributor == request.user:
                continue # users shall not vote about themselves
            if not contributor in form_group:
                form_group[contributor] = SortedDict()
            form_group[contributor][(contribution, questionnaire)] = form

    for contributor in form_group:
        for (contribution, questionnaire), form in form_group[contributor].items():
            for question in questionnaire.question_set.all():
                identifier = make_form_identifier(contribution, questionnaire, question)

    for contributor in form_group:
        for form in form_group[contributor].values():
            if form.is_valid():
                continue
            course_forms = []
            contributor_questionnaires = {}
            errors = []

            for form in form_group[None].values():
                course_forms.append(form)

            for contributor in form_group:
                if contributor == None:
                    continue
                user_profile = UserProfile.get_for_user(contributor)
                contributor_questionnaires[user_profile] = form_group[contributor].values()
                for form in form_group[contributor].values():
                    if form.errors:
                        errors.append(contributor.id)

            return render_to_response(
                "student_vote.html",
                dict(course_forms=course_forms,
                     contributor_questionnaires=contributor_questionnaires,
                     errors=errors,
                     course=course),
                context_instance=RequestContext(request))

    # all forms are valid
    # begin vote operation
    with transaction.commit_on_success():
        for contributor in form_group:
            for (contribution, questionnaire), form in form_group[contributor].items():
                for question in questionnaire.question_set.all():
                    identifier = make_form_identifier(contribution, questionnaire, question)
                    value = form.cleaned_data.get(identifier)

                    if type(value) in [str, unicode]:
                        value = value.strip()

                    if value == 6: #no answer
                        value = None

                    # store the answer if one was given
                    if value:
                        question.answer_class.objects.create(
                            contribution=contribution,
                            question=question,
                            answer=value)

        # remember that the user voted already
        course.voters.add(request.user)

    messages.add_message(request, messages.INFO, _("Your vote was recorded."))
    return redirect('evap.student.views.index')
Exemple #13
0
def vote(request, course_id):
    # retrieve course and make sure that the user is allowed to vote
    course = get_object_or_404(Course, id=course_id)
    if not course.can_user_vote(request.user):
        raise PermissionDenied

    # prevent a user from voting on themselves.
    contributions_to_vote_on = course.contributions.exclude(
        contributor=request.user).all()
    form_groups = helper_create_voting_form_groups(request,
                                                   contributions_to_vote_on)

    if not all(
            all(form.is_valid() for form in form_group)
            for form_group in form_groups.values()):
        errors_exist = any(
            helper_has_errors(form_group)
            for form_group in form_groups.values())

        course_form_group = form_groups.pop(course.general_contribution)

        contributor_form_groups = list(
            (contribution.contributor, contribution.label, form_group,
             helper_has_errors(form_group))
            for contribution, form_group in form_groups.items())

        template_data = dict(errors_exist=errors_exist,
                             course_form_group=course_form_group,
                             contributor_form_groups=contributor_form_groups,
                             course=course,
                             participants_warning=course.num_participants <= 5,
                             preview=False)
        return render(request, "student_vote.html", template_data)

    # all forms are valid, begin vote operation
    with transaction.atomic():
        for contribution, form_group in form_groups.items():
            for questionnaire_form in form_group:
                questionnaire = questionnaire_form.questionnaire
                for question in questionnaire.question_set.all():
                    identifier = make_form_identifier(contribution,
                                                      questionnaire, question)
                    value = questionnaire_form.cleaned_data.get(identifier)

                    if question.is_text_question:
                        if value:
                            question.answer_class.objects.create(
                                contribution=contribution,
                                question=question,
                                answer=value)
                    else:
                        if value != 6:
                            answer_counter, created = question.answer_class.objects.get_or_create(
                                contribution=contribution,
                                question=question,
                                answer=value)
                            answer_counter.add_vote()
                            answer_counter.save()

        # remember that the user voted already
        course.voters.add(request.user)

        course.was_evaluated(request)

    messages.success(request, _("Your vote was recorded."))
    return redirect('student:index')
Exemple #14
0
def vote(request, course_id):
    # retrieve course and make sure that the user is allowed to vote
    course = get_object_or_404(Course, id=course_id)
    if not course.can_user_vote(request.user):
        raise PermissionDenied

    # prevent a user from voting on themselves.
    contributions_to_vote_on = course.contributions.exclude(
        contributor=request.user).all()
    form_groups = helper_create_voting_form_groups(request,
                                                   contributions_to_vote_on)

    if not all(
            all(form.is_valid() for form in form_group)
            for form_group in form_groups.values()):
        errors_exist = any(
            helper_has_errors(form_group)
            for form_group in form_groups.values())

        course_form_group = form_groups.pop(course.general_contribution)

        contributor_form_groups = list(
            (contribution.contributor, contribution.label, form_group,
             helper_has_errors(form_group))
            for contribution, form_group in form_groups.items())

        template_data = dict(errors_exist=errors_exist,
                             course_form_group=course_form_group,
                             contributor_form_groups=contributor_form_groups,
                             course=course,
                             participants_warning=course.num_participants <= 5,
                             preview=False)
        return render(request, "student_vote.html", template_data)

    # all forms are valid, begin vote operation
    with transaction.atomic():
        # add user to course.voters
        # not using course.voters.add(request.user) since it fails silently when done twice.
        # manually inserting like this gives us the 'created' return value and ensures at the database level that nobody votes twice.
        __, created = course.voters.through.objects.get_or_create(
            userprofile_id=request.user.pk, course_id=course.pk)
        if not created:  # vote already got recorded, bail out
            raise SuspiciousOperation(
                "A second vote has been received shortly after the first one.")

        for contribution, form_group in form_groups.items():
            for questionnaire_form in form_group:
                questionnaire = questionnaire_form.questionnaire
                for question in questionnaire.question_set.all():
                    identifier = make_form_identifier(contribution,
                                                      questionnaire, question)
                    value = questionnaire_form.cleaned_data.get(identifier)

                    if question.is_text_question:
                        if value:
                            question.answer_class.objects.create(
                                contribution=contribution,
                                question=question,
                                answer=value)
                    else:
                        if value != 6:
                            answer_counter, __ = question.answer_class.objects.get_or_create(
                                contribution=contribution,
                                question=question,
                                answer=value)
                            answer_counter.add_vote()
                            answer_counter.save()

        course.course_evaluated.send(sender=Course,
                                     request=request,
                                     semester=course.semester)

    messages.success(request, _("Your vote was recorded."))
    return redirect('student:index')