Exemple #1
0
def delete_data_senders(request):
    manager = get_database_manager(request.user)
    organization = get_organization(request)
    entity_type = request.POST['entity_type']
    all_ids = data_sender_short_codes(request, manager)
    superusers = rep_id_name_dict_of_users(manager)
    non_superuser_rep_ids = [
        id for id in all_ids if id not in superusers.keys()
    ]
    transport_info = TransportInfo("web", request.user.username, "")

    delete_datasenders_from_project(manager, non_superuser_rep_ids)
    delete_entity_instance(manager, non_superuser_rep_ids, entity_type,
                           transport_info)
    delete_datasender_users_if_any(non_superuser_rep_ids, organization)
    if organization.in_trial_mode:
        delete_datasender_for_trial_mode(manager, non_superuser_rep_ids,
                                         entity_type)
    log_activity(
        request,
        DELETED_DATA_SENDERS,
        "%s: [%s]" %
        (entity_type.capitalize(), ", ".join(non_superuser_rep_ids)),
    )
    messages = get_success_message(entity_type)
    return HttpResponse(json.dumps({'success': True, 'message': messages}))
Exemple #2
0
def registered_datasenders(request, project_id):
    manager = get_database_manager(request.user)
    questionnaire = Project.get(manager, project_id)
    project_links = get_project_link(questionnaire)
    dashboard_page = settings.HOME_PAGE + "?deleted=true"
    if questionnaire.is_void():
        return HttpResponseRedirect(dashboard_page)
    if request.method == 'GET':
        in_trial_mode = _in_trial_mode(request)
        user_rep_id_name_dict = rep_id_name_dict_of_users(manager)
        return render_to_response(
            'project/registered_datasenders.html', {
                'project': questionnaire,
                'project_links': project_links,
                'questionnaire_code': questionnaire.form_code,
                'current_language': translation.get_language(),
                'is_quota_reached': is_quota_reached(request),
                'in_trial_mode': in_trial_mode,
                'user_dict': json.dumps(user_rep_id_name_dict)
            },
            context_instance=RequestContext(request))
    if request.method == 'POST':
        error_message, failure_imports, success_message, successful_imports = import_module.import_data(
            request, manager, default_parser=XlsDatasenderParser)
        imported_data_senders = parse_successful_imports(successful_imports)
        imported_datasenders_ids = [
            imported_data_sender["id"]
            for imported_data_sender in imported_data_senders
        ]
        _add_imported_datasenders_to_project(imported_datasenders_ids, manager,
                                             questionnaire)

        if len(imported_datasenders_ids):
            UserActivityLog().log(request,
                                  action=IMPORTED_DATA_SENDERS,
                                  detail=json.dumps(
                                      dict({
                                          "Unique ID":
                                          "[%s]" %
                                          ", ".join(imported_datasenders_ids)
                                      })),
                                  project=questionnaire.name)
        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,
                'successful_imports':
                imported_data_senders
            }))
def registered_datasenders(request, project_id):
    manager = get_database_manager(request.user)
    project, project_links = _get_project_and_project_link(manager, project_id)
    if request.method == 'GET':
        in_trial_mode = _in_trial_mode(request)
        user_rep_id_name_dict = rep_id_name_dict_of_users(manager)
        return render_to_response(
            'project/registered_datasenders.html', {
                'project': project,
                'project_links': project_links,
                'current_language': translation.get_language(),
                'is_quota_reached': is_quota_reached(request),
                'in_trial_mode': in_trial_mode,
                'user_dict': json.dumps(user_rep_id_name_dict)
            },
            context_instance=RequestContext(request))
    if request.method == 'POST':
        error_message, failure_imports, success_message, imported_entities, successful_imports = import_module.import_data(
            request, manager, default_parser=XlsDatasenderParser)
        imported_data_senders = _parse_successful_imports(successful_imports)
        imported_datasenders_ids = [
            imported_data_sender["id"]
            for imported_data_sender in imported_data_senders
        ]
        _add_imported_datasenders_to_project(imported_datasenders_ids, manager,
                                             project)

        if len(imported_datasenders_ids):
            UserActivityLog().log(request,
                                  action=IMPORTED_DATA_SENDERS,
                                  detail=json.dumps(
                                      dict({
                                          "Unique ID":
                                          "[%s]" %
                                          ", ".join(imported_datasenders_ids)
                                      })),
                                  project=project.name)
        org_id = request.user.get_profile().org_id
        _add_imported_datasenders_to_trail_account(imported_data_senders,
                                                   org_id)
        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,
                'successful_imports':
                imported_data_senders
            }))
    def get(self, request, *args, **kwargs):
        manager = get_database_manager(request.user)
        projects = get_all_projects(manager)
        in_trial_mode = utils.get_organization(request).in_trial_mode
        user_rep_id_name_dict = rep_id_name_dict_of_users(manager)

        return self.render_to_response({
            "user_dict": json.dumps(user_rep_id_name_dict),
            "projects": projects,
            'current_language': translation.get_language(),
            'in_trial_mode': in_trial_mode
        })
    def post(self, request, *args, **kwargs):
        manager = get_database_manager(request.user)
        selected_rep_ids = data_sender_short_codes(request, manager)
        users = rep_id_name_dict_of_users(manager)
        users_selected = []

        non_superuser_selected = []
        for rep_id in selected_rep_ids:
            if rep_id in users.keys():
                users_selected.append(users[rep_id])
            else:
                non_superuser_selected.append(rep_id)

        return HttpResponse(json.dumps({"success": True, "superusers_selected": users_selected}))
    def get(self, request, *args, **kwargs):
        manager = get_database_manager(request.user)
        project_name_id_map = get_project_id_name_map(manager)
        organization = utils.get_organization(request)
        in_trial_mode = organization.in_trial_mode
        is_pro_sms = organization.is_pro_sms
        user_rep_id_name_dict = rep_id_name_dict_of_users(manager)
        groups = get_group_details(manager)

        return self.render_to_response(RequestContext(request, {
            "user_dict": json.dumps(user_rep_id_name_dict),
            "projects": project_name_id_map,
            'current_language': translation.get_language(),
            'in_trial_mode': in_trial_mode,
            'is_pro_sms': is_pro_sms,
            'groups': repr(json.dumps(groups, default=field_to_json))
        }))
def registered_datasenders(request, project_id):
    manager = get_database_manager(request.user)
    questionnaire = Project.get(manager, project_id)
    project_links = get_project_link(questionnaire)
    dashboard_page = settings.HOME_PAGE + "?deleted=true"
    if questionnaire.is_void():
        return HttpResponseRedirect(dashboard_page)
    if request.method == 'GET':
        in_trial_mode = _in_trial_mode(request)
        is_open_survey_allowed = _is_pro_sms(
            request) and not questionnaire.xform
        is_open_survey = 'open' if questionnaire.is_open_survey else 'restricted'
        user_rep_id_name_dict = rep_id_name_dict_of_users(manager)
        return render_to_response(
            'project/registered_datasenders.html', {
                'project': questionnaire,
                'project_links': project_links,
                'questionnaire_code': questionnaire.form_code,
                'current_language': translation.get_language(),
                'is_quota_reached': is_quota_reached(request),
                'in_trial_mode': in_trial_mode,
                'is_open_survey_allowed': is_open_survey_allowed,
                'is_open_survey': is_open_survey,
                'user_dict': json.dumps(user_rep_id_name_dict)
            },
            context_instance=RequestContext(request))
    if request.method == 'POST':
        error_message, failure_imports, success_message, successful_imports = import_module.import_data(
            request,
            manager,
            default_parser=XlsDatasenderParser,
            is_datasender=True)
        imported_data_senders = parse_successful_imports(successful_imports)

        reporter_id_email_map = dict([
            (imported_datasender['id'], imported_datasender['email'])
            for imported_datasender in imported_data_senders
        ])
        org_id = request.user.get_profile().org_id
        create_web_users(org_id, reporter_id_email_map, request.LANGUAGE_CODE)

        imported_datasenders_ids = [
            imported_data_sender["id"]
            for imported_data_sender in imported_data_senders
        ]
        _add_imported_datasenders_to_project(imported_datasenders_ids, manager,
                                             questionnaire)
        convert_open_submissions_to_registered_submissions.delay(
            manager.database_name, imported_datasenders_ids)

        if len(imported_datasenders_ids):
            UserActivityLog().log(request,
                                  action=IMPORTED_DATA_SENDERS,
                                  detail=json.dumps(
                                      dict({
                                          "Unique ID":
                                          "[%s]" %
                                          ", ".join(imported_datasenders_ids)
                                      })),
                                  project=questionnaire.name)
        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,
                'successful_imports':
                imported_data_senders
            }))