Example #1
0
def project_results(request, project_id=None, questionnaire_code=None):
    manager = get_database_manager(request)
    project = models.get_project(project_id, dbm=manager)
    project_links = _make_project_links(project, questionnaire_code)
    if request.method == 'GET':
        count, results, error_message = _get_submissions(
            manager, questionnaire_code, request)
        return render_to_response('project/results.html', {
            'questionnaire_code': questionnaire_code,
            'results': results,
            'pages': count,
            'error_message': error_message,
            'project_links': project_links,
            'project': project
        },
                                  context_instance=RequestContext(request))
    if request.method == "POST":
        data_record_ids = json.loads(request.POST.get('id_list'))
        for each in data_record_ids:
            data_record = manager._load_document(each, DataRecordDocument)
            manager.invalidate(each)
            SubmissionLogger(manager).void_data_record(
                data_record.submission.get("submission_id"))
        current_page = request.POST.get('current_page')
        count, results = _load_submissions(int(current_page), manager,
                                           questionnaire_code)
        return render_to_response(
            'project/log_table.html', {
                'questionnaire_code': questionnaire_code,
                'results': results,
                'pages': count,
                'success_message': "The selected records have been deleted"
            },
            context_instance=RequestContext(request))
Example #2
0
def questionnaire_preview(request, project_id=None):
    manager = get_database_manager(request)
    if request.method == 'GET':
        previous_link = reverse(subjects_wizard, args=[project_id])
        project = models.get_project(project_id, manager)
        form_model = helper.load_questionnaire(manager, project.qid)
        fields = form_model.fields
        if form_model.entity_defaults_to_reporter():
            fields = helper.hide_entity_question(form_model.fields)
        project_links = _make_project_links(project, form_model.form_code)
        questions = []
        for field in fields:
            question = helper.get_preview_for_field(field)
            questions.append(question)
        example_sms = "%s +%s <answer> .... +%s <answer>" % (
            form_model.form_code, fields[0].code, fields[len(fields) - 1].code)
        return render_to_response('project/questionnaire_preview.html', {
            "questions": questions,
            'questionnaire_code': form_model.form_code,
            "previous": previous_link,
            'project': project,
            'project_links': project_links,
            'example_sms': example_sms
        },
                                  context_instance=RequestContext(request))
Example #3
0
def project_data(request, project_id=None, questionnaire_code=None):
    manager = get_database_manager(request)
    project = models.get_project(project_id, dbm=manager)
    form_model = get_form_model_by_code(manager, questionnaire_code)
    project_links = _make_project_links(project, questionnaire_code)

    if request.method == "GET":
        data_dictionary = data.aggregate_for_form(
            manager,
            form_code=questionnaire_code,
            aggregates={"*": data.reduce_functions.LATEST},
            aggregate_on=EntityAggregration())
        response_string, header_list, type_list = _format_data_for_presentation(
            data_dictionary, form_model)
        return render_to_response('project/data_analysis.html', {
            "entity_type": form_model.entity_type[0],
            "data_list": repr(response_string),
            "header_list": header_list,
            "type_list": type_list,
            'project_links': project_links,
            'project': project
        },
                                  context_instance=RequestContext(request))
    if request.method == "POST":
        data_dictionary = _load_data(form_model, manager, questionnaire_code,
                                     request)
        response_string, header_list, type_list = _format_data_for_presentation(
            data_dictionary, form_model)
        return HttpResponse(response_string)
Example #4
0
def save_questionnaire(request):
    manager = get_database_manager(request)
    if request.method == 'POST':
        questionnaire_code = request.POST['questionnaire-code']
        json_string = request.POST['question-set']
        question_set = json.loads(json_string)
        pid = request.POST['pid']
        project = models.get_project(pid, dbm=manager)
        form_model = manager.get(project.qid, FormModel)
        try:
            form_model = helper.update_questionnaire_with_questions(form_model, question_set, manager)
        except QuestionCodeAlreadyExistsException as e:
            return HttpResponseServerError(e)
        except EntityQuestionAlreadyExistsException as e:
            return HttpResponseServerError(e.message)
        else:
            try:
                form_model.form_code = questionnaire_code.lower()
            except DataObjectAlreadyExists as e:
                if e.message.find("Form") >= 0:
                    return HttpResponseServerError("Questionnaire with this code already exists")
                return HttpResponseServerError(e.message)
            form_model.name = project.name
            form_model.entity_id = project.entity_type
            form_model.save()
            return HttpResponse(json.dumps({"response": "ok"}))
Example #5
0
def edit_profile(request, project_id=None):
    manager = get_database_manager(request)
    entity_list = get_all_entity_types(manager)
    entity_list = helper.remove_reporter(entity_list)
    project = models.get_project(project_id, dbm=manager)
    if request.method == 'GET':
        form = ProjectProfile(data=project, entity_list=entity_list)
        return render_to_response('project/profile.html', {'form': form, 'project': project, 'edit':True},
                                  context_instance=RequestContext(request))

    form = ProjectProfile(data=request.POST, entity_list=entity_list)
    if form.is_valid():
        older_entity_type = project.entity_type
        if older_entity_type != form.cleaned_data["entity_type"]:
           new_questionnaire =  helper.create_questionnaire(form.cleaned_data, manager)
           new_qid = new_questionnaire.save()
           project.qid = new_qid
        project.update(form.cleaned_data)
        project.update_questionnaire(manager)

        try:
            pid = project.save(manager)
        except DataObjectAlreadyExists as e:
            messages.error(request, e.message)
            return render_to_response('project/profile.html', {'form': form, 'project': project, 'edit':True},
                                      context_instance=RequestContext(request))
        return HttpResponseRedirect(reverse(subjects_wizard, args=[pid]))
    else:
        return render_to_response('project/profile.html', {'form': form, 'project': project, 'edit':True},
                                  context_instance=RequestContext(request))
Example #6
0
def save_questionnaire(request):
    manager = get_database_manager(request)
    if request.method == 'POST':
        questionnaire_code = request.POST['questionnaire-code']
        json_string = request.POST['question-set']
        question_set = json.loads(json_string)
        pid = request.POST['pid']
        project = models.get_project(pid, dbm=manager)
        form_model = manager.get(project.qid, FormModel)
        try:
            form_model = helper.update_questionnaire_with_questions(
                form_model, question_set, manager)
        except QuestionCodeAlreadyExistsException as e:
            return HttpResponseServerError(e)
        except EntityQuestionAlreadyExistsException as e:
            return HttpResponseServerError(e.message)
        else:
            try:
                form_model.form_code = questionnaire_code.lower()
            except DataObjectAlreadyExists as e:
                if e.message.find("Form") >= 0:
                    return HttpResponseServerError(
                        "Questionnaire with this code already exists")
                return HttpResponseServerError(e.message)
            form_model.name = project.name
            form_model.entity_id = project.entity_type
            form_model.save()
            return HttpResponse(json.dumps({"response": "ok"}))
Example #7
0
def index(request):

    manager = get_database_manager(request)
    rows = models.get_all_projects(dbm=manager)
    project_list = []
    for row in rows:
        analysis = log = "#"
        disabled = "disable_link"
        project_id = row['value']['_id']
        project = models.get_project(project_id, dbm=manager)
        questionnaire = manager.get(project['qid'], FormModel)
        questionnaire_code = questionnaire.form_code
        link = reverse(project_overview, args=[project_id])
        if project.state != ProjectState.INACTIVE:
            disabled = ""
            analysis = reverse(project_data,
                               args=[project_id, questionnaire_code])
            log = reverse(project_results,
                          args=[project_id, questionnaire_code])

        project = dict(name=row['value']['name'],
                       created=row['value']['created'],
                       type=row['value']['project_type'],
                       link=link,
                       log=log,
                       analysis=analysis,
                       disabled=disabled)
        project_list.append(project)
    return render_to_response('alldata/index.html', {'projects': project_list},
                              context_instance=RequestContext(request))
Example #8
0
def project_overview(request, project_id=None):
    manager = get_database_manager(request)
    project = models.get_project(project_id, dbm=manager)
    link = reverse(edit_profile, args=[project_id])
    questionnaire = helper.load_questionnaire(manager, project['qid'])
    number_of_questions = len(questionnaire.fields)
    project_links = _make_project_links(project, questionnaire.form_code)
    return render_to_response('project/overview.html',
            {'project': project, 'entity_type': project['entity_type'], 'project_links': project_links
             , 'project_profile_link': link, 'number_of_questions': number_of_questions},
                              context_instance=RequestContext(request))
Example #9
0
def questionnaire_wizard(request, project_id=None):
    manager = get_database_manager(request)
    if request.method == 'GET':
        previous_link = reverse(subjects_wizard, args=[project_id])
        project = models.get_project(project_id, manager)
        form_model = helper.load_questionnaire(manager, project.qid)
        fields = form_model.fields
        if form_model.entity_defaults_to_reporter():
            fields = helper.hide_entity_question(form_model.fields)
        existing_questions = json.dumps(fields, default=field_to_json)
        return render_to_response('project/questionnaire_wizard.html',
                {"existing_questions": repr(existing_questions), 'questionnaire_code': form_model.form_code,
                 "previous": previous_link, 'project': project}, context_instance=RequestContext(request))
Example #10
0
def sender_registration_form_preview(request,project_id=None):
    manager = get_database_manager(request)
    project = models.get_project(project_id, manager)
    if request.method == "GET":
        fields, previous_link, project_links, questions, registration_questionnaire = _get_registration_form(manager,
                                                                                                             project,
                                                                                                             project_id, type_of_subject='Data sender')
        example_sms = "%s +%s <answer> .... +%s <answer>" % (registration_questionnaire.form_code, fields[0].code, fields[len(fields)-1].code)
        datasender_questions = _get_questions_for_datasenders_registration_for_print_preview(questions)
        return render_to_response('project/questionnaire_preview.html',
                {"questions":datasender_questions, 'questionnaire_code': registration_questionnaire.form_code,
                 "previous": previous_link, 'project': project, 'project_links': project_links, 'example_sms':example_sms},
                                  context_instance=RequestContext(request))
Example #11
0
def project_overview(request, project_id=None):
    manager = get_database_manager(request)
    project = models.get_project(project_id, dbm=manager)
    link = reverse(edit_profile, args=[project_id])
    questionnaire = helper.load_questionnaire(manager, project['qid'])
    number_of_questions = len(questionnaire.fields)
    project_links = _make_project_links(project, questionnaire.form_code)
    return render_to_response('project/overview.html', {
        'project': project,
        'entity_type': project['entity_type'],
        'project_links': project_links,
        'project_profile_link': link,
        'number_of_questions': number_of_questions
    },
                              context_instance=RequestContext(request))
Example #12
0
def activate_project(request, project_id=None):
    manager = get_database_manager(request)
    project = models.get_project(project_id, manager)
    project.activate(manager)
    form_model = helper.load_questionnaire(manager, project.qid)
    oneDay = datetime.timedelta(days=1)
    tomorrow = datetime.datetime.now() + oneDay
    submissions, ids = get_submissions_made_for_form(manager, form_model.form_code, start_time=0, end_time=int(mktime(tomorrow.timetuple())) * 1000,
                                                         page_size=None)
    for each in ids:
        if each is not None:
            data_record = manager._load_document(each, DataRecordDocument)
            manager.invalidate(each)
            SubmissionLogger(manager).void_data_record(data_record.submission.get("submission_id"))
    return HttpResponseRedirect(reverse(project_overview, args=[project_id]))
Example #13
0
def subjects_wizard(request, project_id=None):
    if request.method == 'GET':
        manager = get_database_manager(request)
        reg_form = get_form_model_by_code(manager, REGISTRATION_FORM_CODE)
        previous_link = reverse(edit_profile, args=[project_id])
        entity_types = get_all_entity_types(manager)
        project = models.get_project(project_id, manager)
        helper.remove_reporter(entity_types)
        import_subject_form = SubjectUploadForm()
        return render_to_response('project/subjects_wizard.html',
                {'fields': reg_form.fields, "previous": previous_link, "entity_types": entity_types,
                 'import_subject_form': import_subject_form,
                 'post_url': reverse(import_subjects_from_project_wizard), 'project': project, 'step': 'subjects'},
                                  context_instance=RequestContext(request))

    if request.method == 'POST':
        return HttpResponseRedirect(reverse(questionnaire_wizard, args=[project_id]))
Example #14
0
def datasenders_wizard(request, project_id=None):
    if request.method == 'GET':
        manager = get_database_manager(request)
        reg_form = get_form_model_by_code(manager, REGISTRATION_FORM_CODE)
        previous_link = reverse(questionnaire_wizard, args=[project_id])
        project = models.get_project(project_id, manager)
        import_reporter_form = ReporterRegistrationForm()
        _format_field_description_for_data_senders(reg_form.fields)
        cleaned_up_fields = _get_questions_for_datasenders_registration_for_wizard(reg_form.fields)
        return render_to_response('project/datasenders_wizard.html',
                {'fields': cleaned_up_fields, "previous": previous_link,
                 'form': import_reporter_form,
                 'post_url': reverse(import_subjects_from_project_wizard), 'project': project, 'step': 'datasenders'},
                                  context_instance=RequestContext(request))

    if request.method == 'POST':
        return HttpResponseRedirect(reverse(finish, args=[project_id]))
Example #15
0
def questionnaire_wizard(request, project_id=None):
    manager = get_database_manager(request)
    if request.method == 'GET':
        previous_link = reverse(subjects_wizard, args=[project_id])
        project = models.get_project(project_id, manager)
        form_model = helper.load_questionnaire(manager, project.qid)
        fields = form_model.fields
        if form_model.entity_defaults_to_reporter():
            fields = helper.hide_entity_question(form_model.fields)
        existing_questions = json.dumps(fields, default=field_to_json)
        return render_to_response(
            'project/questionnaire_wizard.html', {
                "existing_questions": repr(existing_questions),
                'questionnaire_code': form_model.form_code,
                "previous": previous_link,
                'project': project
            },
            context_instance=RequestContext(request))
Example #16
0
def edit_profile(request, project_id=None):
    manager = get_database_manager(request)
    entity_list = get_all_entity_types(manager)
    entity_list = helper.remove_reporter(entity_list)
    project = models.get_project(project_id, dbm=manager)
    if request.method == 'GET':
        form = ProjectProfile(data=project, entity_list=entity_list)
        return render_to_response('project/profile.html', {
            'form': form,
            'project': project,
            'edit': True
        },
                                  context_instance=RequestContext(request))

    form = ProjectProfile(data=request.POST, entity_list=entity_list)
    if form.is_valid():
        older_entity_type = project.entity_type
        if older_entity_type != form.cleaned_data["entity_type"]:
            new_questionnaire = helper.create_questionnaire(
                form.cleaned_data, manager)
            new_qid = new_questionnaire.save()
            project.qid = new_qid
        project.update(form.cleaned_data)
        project.update_questionnaire(manager)

        try:
            pid = project.save(manager)
        except DataObjectAlreadyExists as e:
            messages.error(request, e.message)
            return render_to_response('project/profile.html', {
                'form': form,
                'project': project,
                'edit': True
            },
                                      context_instance=RequestContext(request))
        return HttpResponseRedirect(reverse(subjects_wizard, args=[pid]))
    else:
        return render_to_response('project/profile.html', {
            'form': form,
            'project': project,
            'edit': True
        },
                                  context_instance=RequestContext(request))
Example #17
0
def questionnaire_preview(request, project_id=None):
    manager = get_database_manager(request)
    if request.method == 'GET':
        previous_link = reverse(subjects_wizard, args=[project_id])
        project = models.get_project(project_id, manager)
        form_model = helper.load_questionnaire(manager, project.qid)
        fields = form_model.fields
        if form_model.entity_defaults_to_reporter():
            fields = helper.hide_entity_question(form_model.fields)
        project_links = _make_project_links(project, form_model.form_code)
        questions = []
        for field in fields:
            question = helper.get_preview_for_field(field)
            questions.append(question)
        example_sms = "%s +%s <answer> .... +%s <answer>" % (form_model.form_code, fields[0].code, fields[len(fields)-1].code)
        return render_to_response('project/questionnaire_preview.html',
                {"questions": questions, 'questionnaire_code': form_model.form_code,
                 "previous": previous_link, 'project': project, 'project_links': project_links, 'example_sms':example_sms},
                                  context_instance=RequestContext(request))
Example #18
0
def finish(request, project_id=None):
    manager = get_database_manager(request)
    project = models.get_project(project_id, manager)
    form_model = helper.load_questionnaire(manager, project.qid)
    if request.method == 'GET':
        project.to_test_mode(manager)
        number_of_registered_subjects = get_entity_count_for_type(
            manager, project.entity_type)
        number_of_registered_datasenders = get_entity_count_for_type(
            manager, 'reporter')
        profile = request.user.get_profile()
        organization = Organization.objects.get(org_id=profile.org_id)
        from_number = TEST_REPORTER_MOBILE_NUMBER
        organization_settings = OrganizationSetting.objects.get(
            organization=organization)
        to_number = organization_settings.sms_tel_number
        previous_link = reverse(datasenders_wizard, args=[project_id])
        fields = form_model.fields[
            1:] if form_model.entity_defaults_to_reporter(
            ) else form_model.fields
        return render_to_response('project/finish_and_test.html', {
            'from_number':
            from_number,
            'to_number':
            to_number,
            'project':
            project,
            'fields':
            fields,
            'project_links':
            _make_links_for_finish_page(project_id, form_model),
            'number_of_datasenders':
            number_of_registered_datasenders,
            'number_of_subjects':
            number_of_registered_subjects,
            "previous":
            previous_link
        },
                                  context_instance=RequestContext(request))
    if request.method == 'POST':
        return HttpResponseRedirect(
            reverse(project_overview, args=[project_id]))
Example #19
0
def activate_project(request, project_id=None):
    manager = get_database_manager(request)
    project = models.get_project(project_id, manager)
    project.activate(manager)
    form_model = helper.load_questionnaire(manager, project.qid)
    oneDay = datetime.timedelta(days=1)
    tomorrow = datetime.datetime.now() + oneDay
    submissions, ids = get_submissions_made_for_form(
        manager,
        form_model.form_code,
        start_time=0,
        end_time=int(mktime(tomorrow.timetuple())) * 1000,
        page_size=None)
    for each in ids:
        if each is not None:
            data_record = manager._load_document(each, DataRecordDocument)
            manager.invalidate(each)
            SubmissionLogger(manager).void_data_record(
                data_record.submission.get("submission_id"))
    return HttpResponseRedirect(reverse(project_overview, args=[project_id]))
Example #20
0
def project_data(request, project_id=None, questionnaire_code=None):
    manager = get_database_manager(request)
    project = models.get_project(project_id, dbm=manager)
    form_model = get_form_model_by_code(manager, questionnaire_code)
    project_links = _make_project_links(project, questionnaire_code)

    if request.method == "GET":
        data_dictionary = data.aggregate_for_form(manager, form_code=questionnaire_code,
                                                  aggregates={"*": data.reduce_functions.LATEST},
                                                  aggregate_on=EntityAggregration())
        response_string, header_list, type_list = _format_data_for_presentation(data_dictionary, form_model)
        return render_to_response('project/data_analysis.html',
                {"entity_type": form_model.entity_type[0], "data_list": repr(response_string),
                 "header_list": header_list, "type_list": type_list, 'project_links': project_links, 'project': project}
                                  ,
                                  context_instance=RequestContext(request))
    if request.method == "POST":
        data_dictionary = _load_data(form_model, manager, questionnaire_code, request)
        response_string, header_list, type_list = _format_data_for_presentation(data_dictionary, form_model)
        return HttpResponse(response_string)
Example #21
0
def subject_registration_form_preview(request, project_id=None):
    manager = get_database_manager(request)
    project = models.get_project(project_id, manager)
    if request.method == "GET":
        fields, previous_link, project_links, questions, registration_questionnaire = _get_registration_form(
            manager, project, project_id)

        example_sms = "%s +%s <answer> .... +%s <answer>" % (
            registration_questionnaire.form_code, fields[0].code,
            fields[len(fields) - 1].code)
        return render_to_response(
            'project/questionnaire_preview.html', {
                "questions": questions,
                'questionnaire_code': registration_questionnaire.form_code,
                "previous": previous_link,
                'project': project,
                'project_links': project_links,
                'example_sms': example_sms
            },
            context_instance=RequestContext(request))
Example #22
0
def project_results(request, project_id=None, questionnaire_code=None):
    manager = get_database_manager(request)
    project = models.get_project(project_id, dbm=manager)
    project_links = _make_project_links(project, questionnaire_code)
    if request.method == 'GET':
        count, results, error_message  = _get_submissions(manager, questionnaire_code, request)
        return render_to_response('project/results.html',
                {'questionnaire_code': questionnaire_code, 'results': results, 'pages': count,
                 'error_message': error_message, 'project_links': project_links, 'project': project},
                                  context_instance=RequestContext(request)
        )
    if request.method == "POST":
        data_record_ids = json.loads(request.POST.get('id_list'))
        for each in data_record_ids:
            data_record = manager._load_document(each, DataRecordDocument)
            manager.invalidate(each)
            SubmissionLogger(manager).void_data_record(data_record.submission.get("submission_id"))
        current_page = request.POST.get('current_page')
        count, results = _load_submissions(int(current_page), manager, questionnaire_code)
        return render_to_response('project/log_table.html',
                {'questionnaire_code': questionnaire_code, 'results': results, 'pages': count,
                 'success_message': "The selected records have been deleted"}, context_instance=RequestContext(request))
Example #23
0
def finish(request, project_id=None):
    manager = get_database_manager(request)
    project = models.get_project(project_id, manager)
    form_model = helper.load_questionnaire(manager, project.qid)
    if request.method == 'GET':
        project.to_test_mode(manager)
        number_of_registered_subjects = get_entity_count_for_type(manager, project.entity_type)
        number_of_registered_datasenders = get_entity_count_for_type(manager, 'reporter')
        profile = request.user.get_profile()
        organization = Organization.objects.get(org_id=profile.org_id)
        from_number = TEST_REPORTER_MOBILE_NUMBER
        organization_settings = OrganizationSetting.objects.get(organization=organization)
        to_number = organization_settings.sms_tel_number
        previous_link = reverse(datasenders_wizard, args=[project_id])
        fields = form_model.fields[1:] if form_model.entity_defaults_to_reporter() else form_model.fields
        return render_to_response('project/finish_and_test.html', {'from_number':from_number, 'to_number':to_number,
                                                                   'project':project, 'fields': fields, 'project_links': _make_links_for_finish_page(project_id, form_model),
                                                                   'number_of_datasenders': number_of_registered_datasenders,
                                                                   'number_of_subjects': number_of_registered_subjects, "previous": previous_link},
                                                                    context_instance=RequestContext(request))
    if request.method == 'POST':
        return HttpResponseRedirect(reverse(project_overview, args=[project_id]))
Example #24
0
def index(request):

    manager = get_database_manager(request)
    rows = models.get_all_projects(dbm=manager)
    project_list = []
    for row in rows:
        analysis = log = "#"
        disabled = "disable_link"
        project_id = row['value']['_id']
        project = models.get_project(project_id, dbm=manager)
        questionnaire = manager.get(project['qid'], FormModel)
        questionnaire_code=questionnaire.form_code
        link = reverse(project_overview, args=[project_id])
        if project.state != ProjectState.INACTIVE:
            disabled=""
            analysis = reverse(project_data, args=[project_id, questionnaire_code])
            log=reverse(project_results, args=[project_id, questionnaire_code])

        project = dict(name=row['value']['name'], created=row['value']['created'], type=row['value']['project_type'],
                       link=link, log=log, analysis=analysis, disabled=disabled)
        project_list.append(project)
    return render_to_response('alldata/index.html', {'projects': project_list}, context_instance=RequestContext(request))
Example #25
0
def datasenders_wizard(request, project_id=None):
    if request.method == 'GET':
        manager = get_database_manager(request)
        reg_form = get_form_model_by_code(manager, REGISTRATION_FORM_CODE)
        previous_link = reverse(questionnaire_wizard, args=[project_id])
        project = models.get_project(project_id, manager)
        import_reporter_form = ReporterRegistrationForm()
        _format_field_description_for_data_senders(reg_form.fields)
        cleaned_up_fields = _get_questions_for_datasenders_registration_for_wizard(
            reg_form.fields)
        return render_to_response(
            'project/datasenders_wizard.html', {
                'fields': cleaned_up_fields,
                "previous": previous_link,
                'form': import_reporter_form,
                'post_url': reverse(import_subjects_from_project_wizard),
                'project': project,
                'step': 'datasenders'
            },
            context_instance=RequestContext(request))

    if request.method == 'POST':
        return HttpResponseRedirect(reverse(finish, args=[project_id]))
Example #26
0
def subjects_wizard(request, project_id=None):
    if request.method == 'GET':
        manager = get_database_manager(request)
        reg_form = get_form_model_by_code(manager, REGISTRATION_FORM_CODE)
        previous_link = reverse(edit_profile, args=[project_id])
        entity_types = get_all_entity_types(manager)
        project = models.get_project(project_id, manager)
        helper.remove_reporter(entity_types)
        import_subject_form = SubjectUploadForm()
        return render_to_response(
            'project/subjects_wizard.html', {
                'fields': reg_form.fields,
                "previous": previous_link,
                "entity_types": entity_types,
                'import_subject_form': import_subject_form,
                'post_url': reverse(import_subjects_from_project_wizard),
                'project': project,
                'step': 'subjects'
            },
            context_instance=RequestContext(request))

    if request.method == 'POST':
        return HttpResponseRedirect(
            reverse(questionnaire_wizard, args=[project_id]))
Example #27
0
def _get_project_and_project_link(manager, project_id):
    project = models.get_project(project_id, manager)
    questionnaire = helper.load_questionnaire(manager, project.qid)
    project_links = _make_project_links(project, questionnaire.form_code)
    return project, project_links
Example #28
0
def _get_project_and_project_link(manager, project_id):
    project = models.get_project(project_id, manager)
    questionnaire = helper.load_questionnaire(manager, project.qid)
    project_links = _make_project_links(project, questionnaire.form_code)
    return project, project_links
Example #29
0
 def test_get_one_project(self):
     self.assertEquals(
         get_project(self.project1_id, self.dbm)['_id'], self.project1_id)
Example #30
0
 def test_get_one_project(self):
     self.assertEquals(get_project(self.project1_id, self.dbm)['_id'], self.project1_id)