Esempio n. 1
0
def survey_detail(request, slug):
    """ When you load the survey, this view decides what to do. It displays
    the form, redirects to the results page, displays messages, or whatever
    makes sense based on the survey, the user, and the user's entries. """
    survey = _get_survey_or_404(slug, request)
    if not survey.is_open:
        return _survey_results_redirect(request, survey)
    # if not survey.is_open and survey.can_have_public_submissions():
    #     return _survey_results_redirect(request, survey)
    need_login = (survey.is_open
                  and survey.require_login
                  and not request.user.is_authenticated())
    if _can_show_form(request, survey):

        if request.method == 'POST':
            return _survey_submit(request, survey)
        else:
            #create submission with status opened, it will be filtered out in reports
            email = request.GET.get('email')  # contact email is in the querystring

            if email and Contact.objects.filter(email=email):
                contact = Contact.objects.filter(email=email)[0]
                already_submitted = Submission.objects.filter(survey=survey, contact=contact,
                                                              status=Submission.COMPLETED)
                if already_submitted.count() > 0:
                    if survey.allow_multiple_submissions:
                        #get the latest
                        submission_ = already_submitted.latest('submitted_at')
                        # submission_.status = Submission.OPENED
                    else:
                        #redirect to already submitted
                        return render_to_response('admin/survey/thanks_already_submitted.html',
                                                  {'survey': survey},
                                                  context_instance=RequestContext(request))
                else:
                    pending_sub = Submission.objects.filter(survey=survey, contact=contact, status=Submission.OPENED)
                    if len(pending_sub) > 0:
                        submission_ = pending_sub[0]
                    else:
                        submission_ = Submission()
                        submission_.contact = contact
                        submission_.survey = survey
                        submission.is_public = not survey.moderate_submissions
                        submission_.status = Submission.OPENED
                #it cannot be null. ip_address will be updated at submission completed
                submission_.ip_address = _get_remote_ip(request)
                submission_.save()
        forms = forms_for_survey(survey, request)
    elif need_login:
        messages.error(request, 'Per compilare il questionario è necessario autenticarsi.')
        return HttpResponseRedirect(_login_url(request))
    elif survey.can_have_public_submissions():
        return _survey_results_redirect(request, survey, thanks=True)
    else:  # Survey is closed with private results.
        forms = ()
    return _survey_show_form(request, survey, forms)
Esempio n. 2
0
def survey_detail(request,
                  survey_slug,
                  group_slug=None,
                  group_slug_field=None,
                  group_qs=None,
                  template_name='survey/survey_detail.html',
                  extra_context=None,
                  allow_edit_existing_answers=False,
                  *args,
                  **kw):
    """

    """
    survey = get_object_or_404(Survey.objects.filter(visible=True),
                               slug=survey_slug)
    if survey.closed:
        if survey.answers_viewable_by(request.user):
            return HttpResponseRedirect(
                reverse('survey-results', None, (),
                        {'survey_slug': survey_slug}))
        raise Http404  #(_('Page not found.')) # unicode + exceptions = bad
    # if user has a session and have answered some questions
    # and the survey does not accept multiple answers,
    # go ahead and redirect to the answers, or a thank you
    if (hasattr(request, 'session')
            and survey.has_answers_from(request.session.session_key)
            and not survey.allows_multiple_interviews
            and not allow_edit_existing_answers):
        return _survey_redirect(request, survey, group_slug=group_slug)
    # if the survey is restricted to authentified user redirect
    # annonymous user to the login page
    if survey.restricted and str(request.user) == "AnonymousUser":
        return HttpResponseRedirect(
            reverse("auth_login") + "?next=%s" % request.path)
    if request.POST and not hasattr(request, 'session'):
        return HttpResponse(unicode(_('Cookies must be enabled.')), status=403)
    if hasattr(request, 'session'):
        skey = 'survey_%d' % survey.id
        request.session[skey] = (request.session.get(skey, False)
                                 or request.method == 'POST')
        request.session.modified = True  ## enforce the cookie save.
    survey.forms = forms_for_survey(survey, request,
                                    allow_edit_existing_answers)
    if (request.POST and all(form.is_valid() for form in survey.forms)):
        for form in survey.forms:
            form.save()
        return _survey_redirect(request, survey, group_slug=group_slug)
    # Redirect either to 'survey.template_name' if this attribute is set or
    # to the default template
    return render_to_response(template_name, {
        'survey': survey,
        'title': survey.title,
        'group_slug': group_slug
    },
                              context_instance=RequestContext(request))
Esempio n. 3
0
def survey_detail(request, survey_slug,
               group_slug=None, group_slug_field=None, group_qs=None,
               template_name = 'survey/survey_detail.html',
               extra_context=None,
               allow_edit_existing_answers=False,
               *args, **kw):
    """

    """
    filter_fields = {'visible': True, str('slug_' + translation.get_language())  : survey_slug }

    try:
        survey = Survey.objects.get(**filter_fields)
    except Survey.DoesNotExist:
        raise Http404

    if survey.template_name:
        template_name = survey.template_name
    if survey.closed:
        if survey.answers_viewable_by(request.user):
            return HttpResponseRedirect(reverse('survey-results', None, (),
                                                {'survey_slug': survey_slug}))
        raise Http404 #(_('Page not found.')) # unicode + exceptions = bad
    # if user has a session and have answered some questions
    # and the survey does not accept multiple answers,
    # go ahead and redirect to the answers, or a thank you
    if (hasattr(request, 'session') and
        survey.has_answers_from(request.session.session_key) and
        not survey.allows_multiple_interviews and not allow_edit_existing_answers):
        return _survey_redirect(request, survey,group_slug=group_slug)
    # if the survey is restricted to authentified user redirect
    # annonymous user to the login page
    if survey.restricted and str(request.user) == "AnonymousUser":
        return HttpResponseRedirect(reverse("auth_login")+"?next=%s" % request.path)
    if request.POST and not hasattr(request, 'session'):
        return HttpResponse(unicode(_('Cookies must be enabled.')), status=403)
    if hasattr(request, 'session'):
        skey = 'survey_%d' % survey.id
        request.session[skey] = (request.session.get(skey, False) or
                                 request.method == 'POST')
        request.session.modified = True ## enforce the cookie save.
    survey.forms = forms_for_survey(survey, request, allow_edit_existing_answers)
    if (request.POST and all(form.is_valid() for form in survey.forms)):
        for form in survey.forms:
            form.save()
        return _survey_redirect(request, survey,group_slug=group_slug)
    # Redirect either to 'survey.template_name' if this attribute is set or
    # to the default template
    return render_to_response(template_name,
                              {'survey': survey,
                               'title': survey.title,
                               'group_slug': group_slug},
                              context_instance=RequestContext(request))
Esempio n. 4
0
File: views.py Progetto: zouf/as2
def survey_detail(
    request,
    survey_slug,
    group_slug=None,
    group_slug_field=None,
    group_qs=None,
    template_name="survey/survey_detail.html",
    extra_context=None,
    allow_edit_existing_answers=False,
    *args,
    **kw
):
    """

    """
    survey = get_object_or_404(Survey.objects.filter(visible=True), slug=survey_slug)
    if survey.closed:
        if survey.answers_viewable_by(request.user):
            return HttpResponseRedirect(reverse("survey-results", None, (), {"survey_slug": survey_slug}))
        raise Http404  # (_('Page not found.')) # unicode + exceptions = bad
    # if user has a session and have answered some questions
    # and the survey does not accept multiple answers,
    # go ahead and redirect to the answers, or a thank you
    if (
        hasattr(request, "session")
        and survey.has_answers_from(request.session.session_key)
        and not survey.allows_multiple_interviews
        and not allow_edit_existing_answers
    ):
        return _survey_redirect(request, survey, group_slug=group_slug)
    # if the survey is restricted to authentified user redirect
    # annonymous user to the login page
    if survey.restricted and str(request.user) == "AnonymousUser":
        return HttpResponseRedirect(reverse("auth_login") + "?next=%s" % request.path)
    if request.POST and not hasattr(request, "session"):
        return HttpResponse(unicode(_("Cookies must be enabled.")), status=403)
    if hasattr(request, "session"):
        skey = "survey_%d" % survey.id
        request.session[skey] = request.session.get(skey, False) or request.method == "POST"
        request.session.modified = True  ## enforce the cookie save.
    survey.forms = forms_for_survey(survey, request, allow_edit_existing_answers)
    if request.POST and all(form.is_valid() for form in survey.forms):
        for form in survey.forms:
            form.save()
        return _survey_redirect(request, survey, group_slug=group_slug)
    # Redirect either to 'survey.template_name' if this attribute is set or
    # to the default template
    return render_to_response(
        survey.template_name or template_name,
        {"survey": survey, "title": survey.title, "group_slug": group_slug},
        context_instance=RequestContext(request),
    )
Esempio n. 5
0
def embeded_survey_questions(request, slug):
    survey = _get_survey_or_404(slug, request)
    templates = ['admin/survey/embeded_survey_questions_%s.html' % slug,
                 'admin/survey/embeded_survey_questions.html']
    forms = ()
    if _can_show_form(request, survey):
        forms = forms_for_survey(survey, request)
        if request.method == 'POST':
            if _submit_valid_forms(forms, request, survey):
                forms = ()
    return render_to_string(templates, dict(
        entered=_user_entered_survey(request, survey),
        request=request,
        forms=forms,
        survey=survey,
        login_url=_login_url(request)), _rc(request))
Esempio n. 6
0
def survey_detail(request, survey_id,
               group_slug=None, group_slug_field=None, group_qs=None,
               template_name = 'survey/survey_detail.html',
               extra_context=None, allow_edit_existing_answers=False,
               *args, **kw):
    
    flag, survey = get_survey(request.user, survey_id)
    
    # survey, nesse caso, é uma mensagem de falha.
    if not flag: return HttpResponse( survey)
    
    if survey.closed and not is_user_auth( request.user ):
        if survey.answers_viewable_by(request.user):
            return HttpResponseRedirect(reverse('survey-results', None, (), {'survey_id': survey_id}))
        raise Http404 #(_('Page not found.')) # unicode + exceptions = bad
    
    # if user has a session or is authenticated and have answered
    # some questions and the survey does not accept multiple answers,
    # go ahead and redirect to the answers, or a thank you
    if not survey.allows_multiple_interviews and not allow_edit_existing_answers and not is_user_auth( request.user ):
        if ((hasattr(request, 'session') and survey.has_answers_from(request.session.session_key)) or
        (request.user.is_authenticated() and survey.has_answers_from_user(request.user))):
            return _survey_redirect(request, survey, group_slug=group_slug)
        
    # if the survey is restricted to authentified user redirect
    # annonymous user to the login page
    if survey.restricted and request.user.is_anonymous():
        return HttpResponseRedirect(settings.LOGIN_URL+"?next=%s" % request.path)
    
    if request.POST and not hasattr(request, 'session'):
        return HttpResponse(unicode(_('Cookies must be enabled.')), status=403)
    
    if hasattr(request, 'session'):
        skey = 'survey_%d' % survey.id
        request.session[skey] = (request.session.get(skey, False) or request.method == 'POST')
        request.session.modified = True ## enforce the cookie save.
        
    survey.forms = forms_for_survey(survey, request, allow_edit_existing_answers)
    
    if (request.POST and all(form.is_valid() for form in survey.forms)):
        for form in survey.forms: form.save()
        return _survey_redirect(request, survey, group_slug=group_slug)
    
    # Redirect either to 'survey.template_name' if this attribute is set or to the default template
    return render_to_response(survey.template_name or template_name,
                              {'survey': survey, 'title': survey.title, 'group_slug': group_slug},
                              context_instance=RequestContext(request))
Esempio n. 7
0
def _survey_submit(request, survey):
    if survey.require_login and request.user.is_anonymous():
        # again, the form should only be shown after the user is logged in, but
        # to be safe...
        return HttpResponseRedirect(_login_url(request))
    if not hasattr(request, 'session'):
        return HttpResponse("Cookies must be enabled to use this application.",
                            status=httplib.FORBIDDEN)
    if _entered_no_more_allowed(request, survey):
        slug_template = 'admin/survey/%s_already_submitted.html' % survey.slug
        return render_to_response([slug_template,
                                   'admin/survey/already_submitted.html'],
                                  dict(survey=survey),
                                  _rc(request))

    forms = forms_for_survey(survey, request)
    if _submit_valid_forms(forms, request, survey):
        #it never enters here!!!??
        if survey.can_have_public_submissions():
            return _survey_results_redirect(request, survey, thanks=True)
        return _survey_show_form(request, survey, ())
    else:
        return _survey_show_form(request, survey, forms)