Exemple #1
0
def create_type(request):
    success = False
    form = EntityTypeForm(request.POST)
    if form.is_valid():
        entity_name = form.cleaned_data["entity_type_regex"]
        entity_name = [entity_name.strip().lower()]
        try:
            manager = get_database_manager(request.user)
            define_type(manager, entity_name)
            create_registration_form(manager, entity_name)
            message = _("Entity definition successful")
            success = True
            UserActivityLog().log(request,
                                  action=ADDED_SUBJECT_TYPE,
                                  detail=entity_name[0].capitalize())
        except EntityTypeAlreadyDefined:
            if request.POST["referer"] == 'project':
                message = _(
                    "%s already registered as a subject type. Please select %s from the drop down menu."
                ) % (entity_name[0], entity_name[0])
            else:
                message = _("%s already registered as a subject type.") % (
                    entity_name[0], )
    else:
        message = form.fields['entity_type_regex'].error_messages['invalid']
    return HttpResponse(json.dumps({
        'success': success,
        'message': _(message)
    }))
Exemple #2
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"}))
Exemple #3
0
def export_template(request, entity_type=None):
    manager = get_database_manager(request.user)
    if entity_type is None:
        return HttpResponseRedirect(reverse(all_subjects))

    fields, labels, field_codes = import_module.get_entity_type_fields(
        manager, entity_type)
    response = HttpResponse(mimetype='application/vnd.ms-excel')
    response['Content-Disposition'] = 'attachment; filename="%s.xls"' % (
        entity_type, )
    form_model = get_form_model_by_entity_type(manager, [entity_type.lower()])

    wb = get_excel_sheet([labels], entity_type)
    form_code = form_model.form_code
    add_codes_sheet(wb, form_code, field_codes)
    try:
        index_geocode = fields.index(GEO_CODE_FIELD_NAME)
    except ValueError:
        index_geocode = 0

    ws = wb.get_sheet(0)

    style = xlwt.XFStyle()
    style.num_format_str = '@'
    gps_col = ws.col(index_geocode)
    gps_col.set_style(style)

    wb.save(response)
    return response
Exemple #4
0
def datasenders(request, project_id=None):
    manager = get_database_manager(request)
    project, project_links = _get_project_and_project_link(manager, project_id)
    reg_form = get_form_model_by_code(manager, REGISTRATION_FORM_CODE)
    _format_field_description_for_data_senders(reg_form.fields)
    cleaned_up_fields = _get_questions_for_datasenders_registration_for_print_preview(reg_form.fields)
    return render_to_response('project/datasenders.html', {'fields': cleaned_up_fields, 'project':project, 'project_links':project_links}, context_instance=RequestContext(request))
Exemple #5
0
def hierarchy_report(request):
    manager = get_database_manager(request)
    column_headers, values = [], []
    choices = [(t, '.'.join(t)) for t in get_all_entity_types(manager)]

    if request.method == 'POST':
        form = ReportHierarchy(data=request.POST, choices=choices)
        if form.is_valid():
            entity_type = form.cleaned_data['entity_type'].split(".")
            aggregates_field = form.cleaned_data['aggregates_field']
            reduce_function = form.cleaned_data['reduce']
            aggregates = {aggregates_field: reduce_function}
            aggregate_on_path = form.cleaned_data['aggregate_on_path']
            level = form.cleaned_data['level']
            report_data = data.aggregate(manager, entity_type=entity_type,
                                     aggregates=aggregates,
                                     aggregate_on=TypeAggregration(type=aggregate_on_path,level=level),
                                     )
            column_headers, values = tabulate_output(report_data, "Path")
    else:
        form = ReportHierarchy(choices=choices)

    return render_to_response('reports/reportperhierarchypath.html',
                              {'form': form, 'column_headers': column_headers, 'column_values': values},
                              context_instance=RequestContext(request))
Exemple #6
0
def create_profile(request):
    manager = get_database_manager(request)
    entity_list = get_all_entity_types(manager)
    entity_list = helper.remove_reporter(entity_list)
    project_summary = dict(name='New Project')
    if request.method == 'GET':
        form = ProjectProfile(entity_list=entity_list,initial={'activity_report':'yes'})
        return render_to_response('project/profile.html', {'form': form, 'project': project_summary, 'edit':False},
                                  context_instance=RequestContext(request))

    form = ProjectProfile(data=request.POST, entity_list=entity_list)
    if form.is_valid():
        entity_type=form.cleaned_data['entity_type']
        project = Project(name=form.cleaned_data["name"], goals=form.cleaned_data["goals"],
                          project_type=form.cleaned_data['project_type'], entity_type=entity_type,
                          devices=form.cleaned_data['devices'], activity_report=form.cleaned_data['activity_report'], sender_group=form.cleaned_data['sender_group'])
        form_model = helper.create_questionnaire(post=form.cleaned_data, dbm=manager)
        try:
            pid = project.save(manager)
            qid = form_model.save()
            project.qid = qid
            pid = project.save(manager)
        except DataObjectAlreadyExists as e:
            messages.error(request, e.message)
            return render_to_response('project/profile.html', {'form': form, 'project': project_summary, 'edit':False},
                                      context_instance=RequestContext(request))
        return HttpResponseRedirect(reverse(subjects_wizard, args=[pid]))
    else:
        return render_to_response('project/profile.html', {'form': form, 'project': project_summary, 'edit':False},
                                  context_instance=RequestContext(request))
Exemple #7
0
def report(request):
    manager = get_database_manager(request)
    types = get_all_entity_types(manager)
    choices = [('.'.join(t), '.'.join(t)) for t in types]
    column_headers = []
    values = []
    error_message = None
    if request.method == 'POST':
        form = Report(data=request.POST, choices=choices)
        if form.is_valid():
            entity_type = form.cleaned_data['entity_type'].split(".")
            filter_criteria = form.cleaned_data['filter']
            aggregates_field = form.cleaned_data['aggregates_field']
            location = filter_criteria.split(",") if filter_criteria else None
            report_data = data.aggregate(manager, entity_type=entity_type,
                                     aggregates={aggregates_field: data.reduce_functions.LATEST},
                                     filter=LocationFilter(location=location)
            )
            column_headers, values = tabulate_output(report_data, "ID")
            if not len(values):
                error_message = 'Sorry, No records found for this query'
    else:
        form = Report(choices=choices)
    return render_to_response('reports/reportperlocation.html', {'form': form, 'column_headers': column_headers,
                                                                 'column_values': values,
                                                                 'error_message': error_message},
                              context_instance=RequestContext(request))
Exemple #8
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))
Exemple #9
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))
Exemple #10
0
def hierarchy_report(request):
    manager = get_database_manager(request)
    column_headers, values = [], []
    choices = [(t, '.'.join(t)) for t in get_all_entity_types(manager)]

    if request.method == 'POST':
        form = ReportHierarchy(data=request.POST, choices=choices)
        if form.is_valid():
            entity_type = form.cleaned_data['entity_type'].split(".")
            aggregates_field = form.cleaned_data['aggregates_field']
            reduce_function = form.cleaned_data['reduce']
            aggregates = {aggregates_field: reduce_function}
            aggregate_on_path = form.cleaned_data['aggregate_on_path']
            level = form.cleaned_data['level']
            report_data = data.aggregate(
                manager,
                entity_type=entity_type,
                aggregates=aggregates,
                aggregate_on=TypeAggregration(type=aggregate_on_path,
                                              level=level),
            )
            column_headers, values = tabulate_output(report_data, "Path")
    else:
        form = ReportHierarchy(choices=choices)

    return render_to_response('reports/reportperhierarchypath.html', {
        'form': form,
        'column_headers': column_headers,
        'column_values': values
    },
                              context_instance=RequestContext(request))
Exemple #11
0
def report(request):
    manager = get_database_manager(request)
    types = get_all_entity_types(manager)
    choices = [('.'.join(t), '.'.join(t)) for t in types]
    column_headers = []
    values = []
    error_message = None
    if request.method == 'POST':
        form = Report(data=request.POST, choices=choices)
        if form.is_valid():
            entity_type = form.cleaned_data['entity_type'].split(".")
            filter_criteria = form.cleaned_data['filter']
            aggregates_field = form.cleaned_data['aggregates_field']
            location = filter_criteria.split(",") if filter_criteria else None
            report_data = data.aggregate(
                manager,
                entity_type=entity_type,
                aggregates={aggregates_field: data.reduce_functions.LATEST},
                filter=LocationFilter(location=location))
            column_headers, values = tabulate_output(report_data, "ID")
            if not len(values):
                error_message = 'Sorry, No records found for this query'
    else:
        form = Report(choices=choices)
    return render_to_response('reports/reportperlocation.html', {
        'form': form,
        'column_headers': column_headers,
        'column_values': values,
        'error_message': error_message
    },
                              context_instance=RequestContext(request))
Exemple #12
0
def delete_entity(request):
    manager = get_database_manager(request.user)
    organization = get_organization(request)
    transport_info = TransportInfo("web", request.user.username, "")
    entity_type = request.POST['entity_type']
    project = request.POST.get("project", "")
    all_ids = request.POST['all_ids'].split(';')
    ngo_admin_user_profile = get_ngo_admin_user_profiles_for(organization)[0]
    if ngo_admin_user_profile.reporter_id in all_ids:
        messages.error(
            request,
            _("Your organization's account Administrator %s cannot be deleted")
            % (_get_full_name(ngo_admin_user_profile.user)), "error_message")
    else:
        delete_entity_instance(manager, all_ids, entity_type, transport_info)
        if entity_type == REPORTER:
            delete_datasender_from_project(manager, all_ids)
            delete_datasender_users_if_any(all_ids, organization)
            if organization.in_trial_mode:
                delete_datasender_for_trial_mode(manager, all_ids, entity_type)
            action = DELETED_DATA_SENDERS
        else:
            action = DELETED_SUBJECTS
        UserActivityLog().log(request,
                              action=action,
                              detail="%s: [%s]" %
                              (entity_type.capitalize(), ", ".join(all_ids)),
                              project=project.capitalize())
        messages.success(request, get_success_message(entity_type))
    return HttpResponse(json.dumps({'success': True}))
Exemple #13
0
def web_preview(request):
    project_info = json.loads(request.POST['profile_form'])
    manager = get_database_manager(request.user)

    return render_to_response("project/web_instruction_preview.html",
                              get_web_preview_context(manager, request.POST,
                                                      project_info),
                              context_instance=RequestContext(request))
Exemple #14
0
def edit_project(request, project_id=None):
    manager = get_database_manager(request.user)
    entity_list = get_all_entity_types(manager)
    entity_list = helper.remove_reporter(entity_list)
    project = Project.load(manager.database, project_id)
    questionnaire = FormModel.get(manager, project.qid)
    if request.method == 'GET':
        form = CreateProject(data=project, entity_list=entity_list)
        activity_report_questions = json.dumps(helper.get_activity_report_questions(manager), default=field_to_json)
        subject_report_questions = json.dumps(helper.get_subject_report_questions(manager), default=field_to_json)
        fields = questionnaire.fields
        if questionnaire.entity_defaults_to_reporter():
            fields = helper.hide_entity_question(questionnaire.fields)
        existing_questions = json.dumps(fields, default=field_to_json)

        return render_to_response('project/create_project.html',
            {'form': form, "activity_report_questions": repr(activity_report_questions),
             'subject_report_questions': repr(subject_report_questions),
             'preview_links': get_preview_and_instruction_links(),
             'existing_questions': repr(existing_questions), 'questionnaire_code': questionnaire.form_code,
             'project': project, 'is_edit': 'true', 'post_url': reverse(edit_project, args=[project_id])},
            context_instance=RequestContext(request))

    if request.method == 'POST':
        project_info = json.loads(request.POST['profile_form'])
        form = CreateProject(entity_list, data=project_info)
        if form.is_valid():
            detail = dict()
            for key, changed in enumerate(form.changed_data):
                if getattr(project, changed) != form.cleaned_data.get(changed):
                    detail.update({changed.capitalize(): form.cleaned_data.get(changed)})
            project.update(form.cleaned_data)
            try:
                old_fields = questionnaire.fields
                questionnaire = update_questionnaire(questionnaire, request.POST, form.cleaned_data['entity_type'],
                    form.cleaned_data['name'], manager, form.cleaned_data['language'])
                changed_questions = get_changed_questions(old_fields, questionnaire.fields, subject=False)
                detail.update(changed_questions)
                project.state = request.POST['project_state']
                project.qid = questionnaire.save()
                UserActivityLog().log(request, project=project.name, action=EDITED_PROJECT, detail=json.dumps(detail))
            except (QuestionCodeAlreadyExistsException, QuestionAlreadyExistsException,
                    EntityQuestionAlreadyExistsException) as ex:
                return HttpResponse(
                    json.dumps({'success': False, 'error_in_project_section': False, 'error_message': _(ex.message)}))
            except DataObjectAlreadyExists:
                return HttpResponse(json.dumps({'success': False, 'error_in_project_section': False,
                                                'error_message': 'Questionnaire with this code already exists'}))

            try:
                project.save(manager)
            except DataObjectAlreadyExists as ex:
                message = _("%s with %s = %s already exists.") % (_(ex.data[2]), _(ex.data[0]), "'%s'" % project.name)
                return HttpResponse(
                    json.dumps({'success': False, 'error_message': message, 'error_in_project_section': True}))

            return HttpResponse(json.dumps({'success': True, 'project_id': project.id}))
Exemple #15
0
def questionnaire_web_preview(request):
    manager = get_database_manager(request.user)
    project_info = Project.load(manager.database, request.POST["project_id"])

    context = get_web_preview_context(manager, request.POST,
                                      project_info) if project_info else {}
    return render_to_response("project/web_instruction_preview.html",
                              context,
                              context_instance=RequestContext(request))
Exemple #16
0
def create_subject(request):
    db_manager = get_database_manager(request)
    entity_types = get_all_entity_types(db_manager)
    project_helper.remove_reporter(entity_types)
    return render_to_response("entity/create_subject.html", {
        "post_url": reverse(submit),
        "entity_types": entity_types
    },
                              context_instance=RequestContext(request))
Exemple #17
0
def sms_preview(request):
    manager = get_database_manager(request.user)
    context = {'org_number': get_organization_telephone_number(request)}
    project_info = json.loads(request.POST['profile_form'])
    context.update(get_sms_preview_context(manager, request.POST,
                                           project_info))

    return render_to_response("project/sms_instruction_preview.html",
                              context,
                              context_instance=RequestContext(request))
Exemple #18
0
def export_data(request):
    questionnaire_code = request.POST.get("questionnaire_code")
    manager = get_database_manager(request)
    form_model = get_form_model_by_code(manager, questionnaire_code)
    data_dictionary = _load_data(form_model, manager, questionnaire_code, request)
    response_string, header_list, type_list = _format_data_for_presentation(data_dictionary, form_model)
    raw_data_list = json.loads(response_string)
    raw_data_list.insert(0, header_list)
    file_name = request.POST.get(u"project_name")+'_analysis'
    return _create_excel_response(raw_data_list, file_name)
Exemple #19
0
def registered_datasenders(request, project_id=None):
    manager = get_database_manager(request)
    project, project_links = _get_project_and_project_link(manager, project_id)
    all_data = load_all_subjects_of_type(request)
    return render_to_response('project/registered_datasenders.html', {
        'project': project,
        'project_links': project_links,
        'all_data': all_data
    },
                              context_instance=RequestContext(request))
Exemple #20
0
def subjects(request, project_id=None):
    manager = get_database_manager(request)
    project, project_links = _get_project_and_project_link(manager, project_id)
    reg_form = get_form_model_by_code(manager, REGISTRATION_FORM_CODE)
    return render_to_response('project/subjects.html', {
        'fields': reg_form.fields,
        'project': project,
        'project_links': project_links
    },
                              context_instance=RequestContext(request))
Exemple #21
0
 def wrapper(*args, **kw):
     request = args[0]
     user = request.user
     dbm = get_database_manager(user)
     project_id = kw["project_id"]
     project = Project.load(dbm.database, project_id)
     if "web" not in project.devices:
         referer = django_settings.HOME_PAGE
         return HttpResponseRedirect(referer)
     return f(*args, **kw)
Exemple #22
0
def import_subjects_from_project_wizard(request):
    manager = get_database_manager(request)
    error_message, failure_imports, success, success_message = import_module.import_data(
        request, manager)
    return HttpResponse(
        json.dumps({
            'success': success,
            'message': success_message,
            'error_message': error_message,
            'failure_imports': failure_imports
        }))
Exemple #23
0
def create_data_sender(request):
    create_data_sender = True
    entity_links = {'back_link': reverse(all_datasenders)}

    if request.method == 'GET':
        form = ReporterRegistrationForm()
        return render_to_response('entity/create_or_edit_data_sender.html', {
            'form': form,
            'create_data_sender': create_data_sender,
            'entity_links': entity_links
        },
                                  context_instance=RequestContext(request))
    if request.method == 'POST':
        dbm = get_database_manager(request.user)
        org_id = request.user.get_profile().org_id
        form = ReporterRegistrationForm(org_id=org_id, data=request.POST)
        success = False
        try:
            reporter_id, message = process_create_data_sender_form(
                dbm, form, org_id)
            success = True
        except DataObjectAlreadyExists as e:
            message = _(
                "Data Sender with Unique Identification Number (ID) = %s already exists."
            ) % e.data[1]
        if len(form.errors) == 0 and form.requires_web_access() and success:
            email_id = request.POST['email']
            create_single_web_user(org_id=org_id,
                                   email_address=email_id,
                                   reporter_id=reporter_id,
                                   language_code=request.LANGUAGE_CODE)

        if message is not None and success:
            if form.cleaned_data['project_id'] != "":
                project = Project.load(dbm.database,
                                       form.cleaned_data['project_id'])
                project = project.name
            else:
                project = ""
            if not len(form.errors):
                UserActivityLog().log(request,
                                      action=REGISTERED_DATA_SENDER,
                                      detail=json.dumps(
                                          dict({"Unique ID": reporter_id})),
                                      project=project)
            form = ReporterRegistrationForm(
                initial={'project_id': form.cleaned_data['project_id']})
        return render_to_response('datasender_form.html', {
            'form': form,
            'message': message,
            'success': success,
            'entity_links': entity_links
        },
                                  context_instance=RequestContext(request))
Exemple #24
0
def questionnaire_sms_preview(request):
    manager = get_database_manager(request.user)
    context = {'org_number': get_organization_telephone_number(request)}
    project_info = Project.load(manager.database, request.POST['project_id'])
    if project_info:
        context.update(
            get_sms_preview_context(manager, request.POST, project_info))

    return render_to_response("project/sms_instruction_preview.html",
                              context,
                              context_instance=RequestContext(request))
Exemple #25
0
def load_all_subjects_of_type(request, entity_type="reporter"):
    manager = get_database_manager(request)
    rows = get_all_entities(dbm=manager, include_docs=True)
    data = []
    for row in rows:
        type = _get_entity_type_from_row(row)
        entity, short_code = _get_entity_for_row(manager, row, type)
        type = '.'.join(type)
        if type.lower() == entity_type:
            data.append(_tabulate_data(entity, row, short_code, type))
    return data
Exemple #26
0
def load_all_subjects_of_type(request, entity_type="reporter"):
    manager = get_database_manager(request)
    rows = get_all_entities(dbm=manager, include_docs=True)
    data = []
    for row in rows:
        type = _get_entity_type_from_row(row)
        entity, short_code = _get_entity_for_row(manager, row, type)
        type = '.'.join(type)
        if type.lower() == entity_type:
            data.append(_tabulate_data(entity, row, short_code, type))
    return data
Exemple #27
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))
Exemple #28
0
def submissions(request):
    """
            Called via ajax, returns the partial HTML for the submissions made for the project, paginated.
    """
    manager = get_database_manager(request)
    if request.method == 'GET':
        questionnaire_code = request.GET.get('questionnaire_code')
        count,results,error_message = _get_submissions(manager, questionnaire_code, request)
        return render_to_response('project/log_table.html',
                {'questionnaire_code': questionnaire_code, 'results': results, 'pages': count,'error_message': error_message,
                 'success_message': ""}, context_instance=RequestContext(request))
Exemple #29
0
def all_datasenders(request):
    manager = get_database_manager(request)
    if request.method == 'POST':
        error_message, failure_imports, success, success_message = import_module.import_data(request, manager)
        all_data_senders = import_module.load_all_subjects_of_type(request)

        return HttpResponse(json.dumps({'success': success, 'message': success_message, 'error_message': error_message,
                                        'failure_imports': failure_imports, 'all_data': all_data_senders}))
    all_data_senders = import_module.load_all_subjects_of_type(request)
    return render_to_response('entity/all_datasenders.html', {'all_data': all_data_senders},
                              context_instance=RequestContext(request))
Exemple #30
0
def map_entities(request):
    dbm = get_database_manager(request.user)
    project = Project.load(dbm.database, request.GET['project_id'])
    if project.is_activity_report():
        entity_list = [
            get_by_short_code(dbm, short_code, ["reporter"])
            for short_code in project.data_senders
        ]
    else:
        entity_list = get_entities_by_type(dbm, request.GET['id'])
    location_geojson = helper.create_location_geojson(entity_list)
    return HttpResponse(location_geojson)
Exemple #31
0
def export_data(request):
    questionnaire_code = request.POST.get("questionnaire_code")
    manager = get_database_manager(request)
    form_model = get_form_model_by_code(manager, questionnaire_code)
    data_dictionary = _load_data(form_model, manager, questionnaire_code,
                                 request)
    response_string, header_list, type_list = _format_data_for_presentation(
        data_dictionary, form_model)
    raw_data_list = json.loads(response_string)
    raw_data_list.insert(0, header_list)
    file_name = request.POST.get(u"project_name") + '_analysis'
    return _create_excel_response(raw_data_list, file_name)
Exemple #32
0
def datasenders(request, project_id=None):
    manager = get_database_manager(request)
    project, project_links = _get_project_and_project_link(manager, project_id)
    reg_form = get_form_model_by_code(manager, REGISTRATION_FORM_CODE)
    _format_field_description_for_data_senders(reg_form.fields)
    cleaned_up_fields = _get_questions_for_datasenders_registration_for_print_preview(
        reg_form.fields)
    return render_to_response('project/datasenders.html', {
        'fields': cleaned_up_fields,
        'project': project,
        'project_links': project_links
    },
                              context_instance=RequestContext(request))
Exemple #33
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))
Exemple #34
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))
Exemple #35
0
def index(request):
    project_list = []
    rows = models.get_all_projects(dbm=get_database_manager(request))
    for row in rows:
        project_id = row['value']['_id']
        link = reverse(project_overview, args=[project_id])
        activate_link = reverse(activate_project, args=[project_id])
        project = dict(name=row['value']['name'], created=row['value']['created'], type=row['value']['project_type'],
                       link=link, activate_link=activate_link, state=row['value']['state'])
        project["created"] = project["created"].strftime("%d %B, %Y")
        project_list.append(project)
    return render_to_response('project/index.html', {'projects': project_list},
                              context_instance=RequestContext(request))
Exemple #36
0
def create_datasender(request):
    if request.method == 'GET':
        form = ReporterRegistrationForm()
        return render_to_response('entity/create_datasender.html', {'form': form},
                                  context_instance=RequestContext(request))
    if request.method == 'POST':
        dbm = get_database_manager(request)
        form, form_errors, message, success = _validate_post_data(dbm, request)
        if success:
            form = ReporterRegistrationForm()
        response = render_to_response('datasender_form.html',
                {'form': form, 'message': message, 'form_errors': form_errors, 'success': success},
                                      context_instance=RequestContext(request))
        return response
Exemple #37
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]))
Exemple #38
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))
Exemple #39
0
def export_log(request):
    questionnaire_code = request.GET.get("questionnaire_code")
    manager = get_database_manager(request)

    count,results,error_message = _get_submissions(manager,questionnaire_code,request,paginate=False)

    header_list = ["To", "From", "Date Received", "Submission status", "Deleted Record","Errors"]
    header_list.extend([each[1] for each in results['questions']])
    raw_data_list = [header_list]
    if count:
        submissions, ids = zip(*results['submissions'])
        raw_data_list.extend([list(each) for each in submissions])

    file_name = request.GET.get(u"project_name")+'_log'
    return _create_excel_response(raw_data_list,file_name)
Exemple #40
0
def create_profile(request):
    manager = get_database_manager(request)
    entity_list = get_all_entity_types(manager)
    entity_list = helper.remove_reporter(entity_list)
    project_summary = dict(name='New Project')
    if request.method == 'GET':
        form = ProjectProfile(entity_list=entity_list,
                              initial={'activity_report': 'yes'})
        return render_to_response('project/profile.html', {
            'form': form,
            'project': project_summary,
            'edit': False
        },
                                  context_instance=RequestContext(request))

    form = ProjectProfile(data=request.POST, entity_list=entity_list)
    if form.is_valid():
        entity_type = form.cleaned_data['entity_type']
        project = Project(name=form.cleaned_data["name"],
                          goals=form.cleaned_data["goals"],
                          project_type=form.cleaned_data['project_type'],
                          entity_type=entity_type,
                          devices=form.cleaned_data['devices'],
                          activity_report=form.cleaned_data['activity_report'],
                          sender_group=form.cleaned_data['sender_group'])
        form_model = helper.create_questionnaire(post=form.cleaned_data,
                                                 dbm=manager)
        try:
            pid = project.save(manager)
            qid = form_model.save()
            project.qid = qid
            pid = project.save(manager)
        except DataObjectAlreadyExists as e:
            messages.error(request, e.message)
            return render_to_response('project/profile.html', {
                'form': form,
                'project': project_summary,
                'edit': False
            },
                                      context_instance=RequestContext(request))
        return HttpResponseRedirect(reverse(subjects_wizard, args=[pid]))
    else:
        return render_to_response('project/profile.html', {
            'form': form,
            'project': project_summary,
            'edit': False
        },
                                  context_instance=RequestContext(request))
Exemple #41
0
def get_submission_breakup(request, project_id):
    dbm = get_database_manager(request.user)
    project = Project.load(dbm.database, project_id)
    form_model = FormModel.get(dbm, project.qid)
    rows = dbm.load_all_rows_in_view('undeleted_submission_log',
                                     startkey=[form_model.form_code],
                                     endkey=[form_model.form_code, {}],
                                     group=True,
                                     group_level=1,
                                     reduce=True)
    submission_success, submission_errors = 0, 0
    for row in rows:
        submission_success = row["value"]["success"]
        submission_errors = row["value"]["count"] - row["value"]["success"]
    response = json.dumps([submission_success, submission_errors])
    return HttpResponse(response)
Exemple #42
0
def create_type(request):
    success = False
    form = EntityTypeForm(request.POST)
    if form.is_valid():
        entity_name = form.cleaned_data["entity_type_regex"]
        entity_name = [entity_name.lower()]
        try:
            manager = get_database_manager(request)
            define_type(manager, entity_name)
            message = "Entity definition successful"
            success = True
        except EntityTypeAlreadyDefined:
            message = "This subject has already been added."
    else:
        message = form.fields['entity_type_regex'].error_messages['invalid']
    return HttpResponse(json.dumps({'success': success, 'message': message}))
Exemple #43
0
def create_type(request):
    success = False
    form = EntityTypeForm(request.POST)
    if form.is_valid():
        entity_name = form.cleaned_data["entity_type_regex"]
        entity_name = [entity_name.lower()]
        try:
            manager = get_database_manager(request)
            define_type(manager, entity_name)
            message = "Entity definition successful"
            success = True
        except EntityTypeAlreadyDefined:
            message = "This subject has already been added."
    else:
        message = form.fields['entity_type_regex'].error_messages['invalid']
    return HttpResponse(json.dumps({'success': success, 'message': message}))
Exemple #44
0
def index(request):
    project_list = []
    rows = models.get_all_projects(dbm=get_database_manager(request))
    for row in rows:
        project_id = row['value']['_id']
        link = reverse(project_overview, args=[project_id])
        activate_link = reverse(activate_project, args=[project_id])
        project = dict(name=row['value']['name'],
                       created=row['value']['created'],
                       type=row['value']['project_type'],
                       link=link,
                       activate_link=activate_link,
                       state=row['value']['state'])
        project["created"] = project["created"].strftime("%d %B, %Y")
        project_list.append(project)
    return render_to_response('project/index.html', {'projects': project_list},
                              context_instance=RequestContext(request))
Exemple #45
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]))
Exemple #46
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]))
Exemple #47
0
def submissions(request):
    """
            Called via ajax, returns the partial HTML for the submissions made for the project, paginated.
    """
    manager = get_database_manager(request)
    if request.method == 'GET':
        questionnaire_code = request.GET.get('questionnaire_code')
        count, results, error_message = _get_submissions(
            manager, questionnaire_code, request)
        return render_to_response('project/log_table.html', {
            'questionnaire_code': questionnaire_code,
            'results': results,
            'pages': count,
            'error_message': error_message,
            'success_message': ""
        },
                                  context_instance=RequestContext(request))
Exemple #48
0
def dashboard(request):
    manager = get_database_manager(request)

    project_list = []
    rows = manager.load_all_rows_in_view('all_projects', descending=True, limit=4)
    for row in rows:
        link = reverse("project-overview",args=(row['value']['_id'],))

        form_model = manager.get(row['value']['qid'], FormModel)
        questionnaire_code = form_model.form_code
        submissions, success, errors = get_submissions(manager, questionnaire_code)

        project = dict(name=row['value']['name'], link=link, submissions=submissions, success=success, errors=errors,
                       inactive=is_project_inactive(row))
        project_list.append(project)

    return render_to_response('dashboard/home.html',
                              {"projects": project_list}, context_instance=RequestContext(request))
Exemple #49
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))
Exemple #50
0
def all_subjects(request, form_code=None):
    manager = get_database_manager(request.user)
    if request.method == 'POST':
        error_message, failure_imports, success_message, imported_entities = import_module.import_data(
            request,
            manager,
            default_parser=XlsOrderedParser,
            form_code=form_code)
        if len(imported_entities) != 0:
            detail_dict = dict()
            for short_code, entity_type in imported_entities.items():
                entity_type = entity_type.capitalize()
                if detail_dict.get(entity_type) is not None:
                    detail_dict.get(entity_type).append(short_code)
                else:
                    detail_dict.update({entity_type: [short_code]})
            for key, detail in detail_dict.items():
                detail_dict.update({key: "[%s]" % ", ".join(detail)})
            UserActivityLog().log(request,
                                  action=IMPORTED_SUBJECTS,
                                  detail=json.dumps(detail_dict))
        subjects_data = import_module.load_all_subjects(manager)
        return HttpResponse(
            json.dumps({
                'success':
                error_message is None and is_empty(failure_imports),
                'message':
                success_message,
                'error_message':
                error_message,
                'failure_imports':
                failure_imports,
                'all_data':
                subjects_data,
                'imported':
                imported_entities.keys()
            }))
    subjects_data = import_module.load_all_subjects(manager)
    return render_to_response('entity/all_subjects.html', {
        'all_data': subjects_data,
        'current_language': translation.get_language(),
        'edit_url': '/entity/subject/edit/'
    },
                              context_instance=RequestContext(request))
Exemple #51
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))
Exemple #52
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))
Exemple #53
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)
Exemple #54
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))
Exemple #55
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))
Exemple #56
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]))
Exemple #57
0
def submit(request):
    dbm = get_database_manager(request)
    post = _get_submission(request.POST)
    success = True
    try:
        web_player = WebPlayer(dbm, SubmissionHandler(dbm))
        message = {k: v for (k, v) in post.get('message').items() if not is_empty(v)}
        if message.get(LOCATION_TYPE_FIELD_CODE) is not None:
            message[LOCATION_TYPE_FIELD_CODE]+= COUNTRY
        request = Request(message=message,
                          transportInfo=TransportInfo(transport=post.get('transport'), source=post.get('source'),
                                                      destination=post.get('destination')))
        response = web_player.accept(request)
        if response.success:
            message = get_success_msg_for_registration_using(response, "web")
        else:
            message = get_submission_error_message_for(response.errors)
        entity_id = response.datarecord_id
    except MangroveException as exception:
        message = get_exception_message_for(exception=exception, channel="web")
        success = False
        entity_id = None
    return HttpResponse(json.dumps({'success': success, 'message': message, 'entity_id': entity_id}))
Exemple #58
0
    def wrapper(*args, **kw):
        if not len(get_all_projects(get_database_manager(args[0]))):
            return HttpResponseRedirect("/start?page=" + args[0].path)

        return f(*args, **kw)
Exemple #59
0
def subjects(request, project_id=None):
    manager = get_database_manager(request)
    project, project_links = _get_project_and_project_link(manager, project_id)
    reg_form = get_form_model_by_code(manager, REGISTRATION_FORM_CODE)
    return render_to_response('project/subjects.html', {'fields': reg_form.fields, 'project':project, 'project_links':project_links}, context_instance=RequestContext(request))
Exemple #60
0
def registered_datasenders(request, project_id=None):
    manager = get_database_manager(request)
    project, project_links = _get_project_and_project_link(manager, project_id)
    all_data = load_all_subjects_of_type(request)
    return render_to_response('project/registered_datasenders.html', {'project':project, 'project_links':project_links, 'all_data':all_data}, context_instance=RequestContext(request))