def get_projects_status(request):
response_projects = []
manager = get_database_manager(request.user)
client_projects = json.loads(request.POST['projects'])
for client_project in client_projects:
try:
server_project = FormModel.get(manager, client_project['id'])
if (server_project._doc.void):
response_projects.appened({
'id': client_project['id'],
'status': 'server-deleted'
})
elif server_project.revision != client_project['rev']:
response_projects.append({
'id': server_project.id,
'status': 'outdated'
})
except Exception:
response_projects.append({
'id': client_project['id'],
'status': 'server-deleted'
})
return response_json_cors(response_projects)
def post(self, request, *args, **kwargs):
manager = get_database_manager(request.user)
questionnaires = self._get_projects(manager, request)
projects_name = Set()
removed_rep_ids = Set()
selected_rep_ids = data_sender_short_codes(request, manager)
for questionnaire in questionnaires:
dashboard_page = settings.HOME_PAGE + "?deleted=true"
if questionnaire.is_void():
return HttpResponseRedirect(dashboard_page)
for rep_id in selected_rep_ids:
if rep_id in questionnaire.data_senders:
questionnaire.delete_datasender(manager, rep_id)
projects_name.add(questionnaire.name.capitalize())
removed_rep_ids.add(rep_id)
if len(removed_rep_ids):
UserActivityLog().log(request,
action=REMOVED_DATA_SENDER_TO_PROJECTS,
detail=json.dumps({
"Unique ID":
"[%s]" % ", ".join(removed_rep_ids),
"Projects":
"[%s]" % ", ".join(projects_name)
}))
return HttpResponse(
json.dumps({
"success":
True,
"message":
_("The Data Sender(s) are removed from Questionnaire(s) successfully"
)
}))
def rename_group(request):
dbm = get_database_manager(request.user)
current_group_name = request.POST['group_name']
new_group_name = request.POST['new_group_name']
try:
group = get_group_by_name(dbm, current_group_name)
if check_uniqueness_of_group(dbm, new_group_name):
contact_ids = _get_reporter_ids_for_group_name(
dbm, current_group_name, None)
_rename_group_for_contacts(contact_ids, dbm, current_group_name,
new_group_name)
group.update_name(new_group_name)
group.save()
return HttpResponse(status=200,
content=json.dumps({'success': True}))
else:
return HttpResponse(
status=200,
content=json.dumps({
'success':
False,
'message':
ugettext("Group with same name already exists.")
}))
except DataObjectNotFound:
return HttpResponse(status=400)
def export_count(request):
if request.method == 'GET':
return HttpResponse(status=405)
submission_type = request.GET.get(u'type')
post_body = json.loads(request.POST['data'])
search_filters = post_body['search_filters']
questionnaire_code = post_body['questionnaire_code']
manager = get_database_manager(request.user)
questionnaire = get_project_by_code(manager, questionnaire_code)
organization = get_organization(request)
local_time_delta = get_country_time_delta(organization.country)
# the number_of_results limit will not be used for result-set size since scan-scroll api does not support it.
# it is specified since the code-flow requires its value to be present
query_params = {
"search_filters": search_filters,
"start_result_number": 0,
"number_of_results": 4000,
"order": "",
"sort_field": "date"
}
search_text = search_filters.get("search_text", '')
query_params.update({"search_text": search_text})
query_params.update({"filter": submission_type})
submission_count = get_submission_count(manager, questionnaire,
query_params, local_time_delta)
return HttpResponse(mimetype='application/json',
content=json.dumps({"count": submission_count}))
def post(self, request, *args, **kwargs):
user = request.user
manager = get_database_manager(user)
search_parameters = {}
search_filters = json.loads(request.POST.get('search_filters', ''))
search_text = request.POST.get('sSearch', '').strip()
search_filters.update({"search_text": search_text})
search_parameters.update(
{"start_result_number": int(request.POST.get('iDisplayStart'))})
search_parameters.update(
{"number_of_results": int(request.POST.get('iDisplayLength'))})
search_parameters.update(
{"sort_field": self._get_order_field(request.POST, manager)})
search_parameters.update({"search_filters": search_filters})
search_parameters.update(
{"order": "-" if request.POST.get('sSortDir_0') == "desc" else ""})
query_fields, datasenders = get_data_sender_search_results(
manager, search_parameters)
total_count = get_data_sender_without_search_filters_count(
manager, search_parameters)
filtered_count = get_data_sender_count(manager, search_parameters)
datasenders = DatasenderQueryResponseCreator().create_response(
datasenders)
return HttpResponse(jsonpickle.encode(
{
'data': datasenders,
'iTotalDisplayRecords': filtered_count,
'iDisplayStart': int(request.POST.get('iDisplayStart')),
"iTotalRecords": total_count,
'iDisplayLength': int(request.POST.get('iDisplayLength'))
},
unpicklable=False),
content_type='application/json')
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)
if entity_type_already_defined(manager, entity_name):
raise EntityTypeAlreadyDefined(u"Type: %s is already defined" %
u'.'.join(entity_name))
create_registration_form(manager, entity_name)
define_type(manager, entity_name)
message = _("Entity definition successful")
success = True
UserActivityLog().log(request,
action=ADDED_IDENTIFICATION_NUMBER_TYPE,
project=entity_name[0].capitalize())
except EntityTypeAlreadyDefined:
message = _("%s already exists.") % (entity_name[0].capitalize(), )
else:
message = form.errors['entity_type_regex']
return HttpResponse(json.dumps({
'success': success,
'message': _(message)
}))
def delete_users(request):
if request.method == 'GET':
raise Http404
django_ids = request.POST.get("all_ids").split(";")
all_ids = NGOUserProfile.objects.filter(user__in=django_ids).values_list(
'reporter_id', flat=True)
manager = get_database_manager(request.user)
organization = get_organization(request)
transport_info = TransportInfo("web", request.user.username, "")
ngo_admin_user_profile = get_ngo_admin_user_profiles_for(organization)[0]
if ngo_admin_user_profile.reporter_id in all_ids:
admin_full_name = ngo_admin_user_profile.user.first_name + ' ' + ngo_admin_user_profile.user.last_name
messages.error(
request,
_("Your organization's account Administrator %s cannot be deleted")
% (admin_full_name), "error_message")
else:
detail = user_activity_log_details(
User.objects.filter(id__in=django_ids))
delete_entity_instance(manager, all_ids, REPORTER, transport_info)
delete_datasenders_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, REPORTER)
action = DELETED_USERS
UserActivityLog().log(request, action=action, detail=detail)
messages.success(request, _("User(s) successfully deleted."))
return HttpResponse(json.dumps({'success': True}))
def sent_reminders(request, project_id):
dbm = get_database_manager(request.user)
dashboard_page = settings.HOME_PAGE + "?deleted=true"
questionnaire = Project.get(dbm, project_id)
if questionnaire.is_void():
return HttpResponseRedirect(dashboard_page)
organization = Organization.objects.get(
org_id=request.user.get_profile().org_id)
is_trial_account = organization.in_trial_mode
html = 'project/sent_reminders_trial.html' if organization.in_trial_mode else 'project/sent_reminders.html'
return render_to_response(html, {
'project':
questionnaire,
"project_links":
make_project_links(questionnaire),
'is_quota_reached':
is_quota_reached(request, organization=organization),
'reminders':
get_all_reminder_logs_for_project(project_id, dbm),
'in_trial_mode':
is_trial_account,
'questionnaire_code':
questionnaire.form_code
},
context_instance=RequestContext(request))
def registered_subjects(request, project_id, entity_type=None):
manager = get_database_manager(request.user)
questionnaire = Project.get(manager, project_id)
dashboard_page = settings.HOME_PAGE + "?deleted=true"
if questionnaire.is_void():
return HttpResponseRedirect(dashboard_page)
current_entity_type = entity_type
if not current_entity_type:
current_entity_type = questionnaire.entity_type[0]
subject = get_entity_type_info(current_entity_type, manager=manager)
project_links = get_project_link(questionnaire, current_entity_type)
subject_form_model = get_form_model_by_entity_type(manager,
[current_entity_type])
in_trial_mode = _in_trial_mode(request)
return render_to_response(
'project/subjects/registered_subjects_list.html', {
'project': questionnaire,
'project_links': project_links,
'is_quota_reached': is_quota_reached(request),
"subject": subject,
'in_trial_mode': in_trial_mode,
'project_id': project_id,
'entity_type': current_entity_type,
'subject_headers': header_fields(subject_form_model),
'questionnaire_code': questionnaire.form_code,
'form_code': subject_form_model.form_code
},
context_instance=RequestContext(request))
def get_submission_breakup(request, project_id):
dbm = get_database_manager(request.user)
questionnaire = Project.get(dbm, project_id)
submission_success, submission_errors = submission_stats(
dbm, questionnaire.id)
response = json.dumps([submission_success, submission_errors])
return HttpResponse(response)
def rename_project(request, project_id):
manager = get_database_manager(request.user)
questionnaire = Project.get(manager, project_id)
new_project_name = request.POST.get('data', '').strip()
if len(new_project_name) == 0:
return HttpResponse(json.dumps({
"status":
"error",
"message":
ugettext("This field is required.")
}),
content_type='application/json')
if (questionnaire.name != new_project_name):
questionnaire.name = new_project_name
try:
questionnaire.save(process_post_update=True)
UserActivityLog().log(request,
action=RENAMED_PROJECT,
project=questionnaire.name)
return HttpResponse(json.dumps({"status": "success"}),
content_type='application/json')
except DataObjectAlreadyExists as e:
return HttpResponse(json.dumps({
"status":
"error",
"message":
ugettext("Questionnaire with same name already exists.")
}),
content_type='application/json')
return HttpResponse(json.dumps({"status": "success"}),
content_type='application/json')
def geo_json_for_project(request, project_id, entity_type=None):
dbm = get_database_manager(request.user)
location_list = []
try:
if entity_type:
first_geocode_field = _get_first_geocode_field_for_entity_type(
dbm, entity_type)
if first_geocode_field:
unique_ids = get_all_entities(dbm, [entity_type], limit=1000)
location_list.extend(
get_location_list_for_entities(first_geocode_field,
unique_ids))
else:
questionnaire = Project.get(dbm, project_id)
unique_ids = by_short_codes(dbm,
questionnaire.data_senders,
["reporter"],
limit=1000)
location_list.extend(get_location_list_for_datasenders(unique_ids))
except DataObjectNotFound:
pass
location_geojson = {"type": "FeatureCollection", "features": location_list}
return HttpResponse(json.dumps(location_geojson))
def get(self, request, reporter_id, *args, **kwargs):
create_data_sender = False
manager = get_database_manager(request.user)
reporter_entity = ReporterEntity(
get_by_short_code(manager, reporter_id, [REPORTER]))
entity_links = {
'registered_datasenders_link': reverse("all_datasenders")
}
datasender = {'short_code': reporter_id}
get_datasender_user_detail(datasender, request.user)
email = datasender.get(
'email') if datasender.get('email') != '--' else False
name = reporter_entity.name
phone_number = reporter_entity.mobile_number
location = reporter_entity.location
geo_code = reporter_entity.geo_code
form = ReporterRegistrationForm(
initial={
'name': name,
'telephone_number': phone_number,
'location': location,
'geo_code': geo_code
})
return self.render_to_response({
'reporter_id': reporter_id,
'form': form,
'project_links': entity_links,
'email': email,
'create_data_sender': create_data_sender
})
def get_questions_paginated_or_by_ids(request):
manager = get_database_manager(request.user)
start = int(request.GET.get('start', '0'))
length = int(request.GET.get('length', '10'))
ids = request.GET.getlist('ids')
if ids:
projects = [
_project_details(manager, project_id) for project_id in ids
]
projects = list(filter(lambda x: x != None, projects))
return response_json_cors(projects)
project_list = []
rows = manager.load_all_rows_in_view('all_projects', descending=True)
for row in rows:
questionnaire = FormModel.get(manager, row['id'])
if questionnaire.xform:
project_temp = dict(name=questionnaire.name,
project_uuid=questionnaire.id,
version=questionnaire._doc.rev)
project_list.append(project_temp)
return response_json_cors({
"projects": project_list[start:start + length],
"total": len(project_list),
"start": start,
"length": length
})
def import_subjects_from_project_wizard(request, form_code):
manager = get_database_manager(request.user)
error_message, failure_imports, success_message, short_code_subject_details_dict = import_module.import_data(
request, manager, default_parser=XlsOrderedParser, form_code=form_code)
subject_details = {}
if len(short_code_subject_details_dict) != 0:
detail_dict = dict()
form_model = get_form_model_by_code(manager, form_code)
entity_type = form_model.entity_type[0]
short_codes = []
for short_code in short_code_subject_details_dict.keys():
short_codes.append(short_code)
subject_details = _format_imported_subjects_datetime_field_to_str(
form_model, short_code_subject_details_dict)
detail_dict.update({entity_type: "[%s]" % ", ".join(short_codes)})
UserActivityLog().log(request,
action=IMPORTED_IDENTIFICATION_NUMBER,
detail=json.dumps(detail_dict))
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':
subject_details,
}))
def questionnaire(request, project_id):
manager = get_database_manager(request.user)
if request.method == 'GET':
questionnaire = Project.get(manager, project_id)
if questionnaire.is_void():
return HttpResponseRedirect(settings.HOME_PAGE + "?deleted=true")
fields = questionnaire.fields
existing_questions = json.dumps(fields, default=field_to_json)
project_links = make_project_links(questionnaire)
success, error = submission_stats(manager, questionnaire.form_code)
project_has_submissions = (success + error > 0)
in_trial_mode = _in_trial_mode(request)
is_success = False
active_language = request.LANGUAGE_CODE
if "success" in [m.message for m in messages.get_messages(request)]:
is_success = True
return render_to_response(
'project/questionnaire.html', {
"existing_questions": repr(existing_questions),
'questionnaire_code': questionnaire.form_code,
'project': questionnaire,
'project_has_submissions': project_has_submissions,
'project_links': project_links,
'is_quota_reached': is_quota_reached(request),
'in_trial_mode': in_trial_mode,
'is_success': is_success,
'active_language': active_language,
'post_url': reverse(edit_project, args=[project_id]),
'unique_id_types': get_unique_id_types(manager),
'preview_links': get_preview_and_instruction_links()
},
context_instance=RequestContext(request))
def map_admin(request, entity_type=None):
form_model = get_form_model_by_entity_type(
get_database_manager(request.user), [entity_type.lower()])
entity_preference = get_entity_preference(get_db_manager("public"),
_get_organization_id(request),
entity_type)
filters_in_entity_preference = []
details_in_entity_preference = []
specials_in_entity_preference = []
if entity_preference is not None:
filters_in_entity_preference = entity_preference.filters
details_in_entity_preference = entity_preference.details
specials_in_entity_preference = entity_preference.specials
filters = _build_filterable_fields(form_model.form_fields,
filters_in_entity_preference)
details = _build_details(form_model.form_fields,
details_in_entity_preference)
specials = _build_specials(form_model.form_fields,
specials_in_entity_preference)
return render_to_response('entity/map_edit.html', {
"entity_type": entity_type,
"form_code": form_model.form_code,
"filters": json.dumps(filters),
"details": json.dumps(details),
"specials": json.dumps(specials)
},
context_instance=RequestContext(request))
def questionnaire_preview(request, project_id=None, sms_preview=False):
manager = get_database_manager(request.user)
if request.method == 'GET':
dashboard_page = settings.HOME_PAGE + "?deleted=true"
questionnaire = Project.get(manager, project_id)
if questionnaire.is_void():
return HttpResponseRedirect(dashboard_page)
#if form_model.is_entity_type_reporter():
# fields = helper.hide_entity_question(form_model.fields)
project_links = make_project_links(questionnaire)
questions = []
fields = questionnaire.fields
for field in fields:
question = helper.get_preview_for_field(field)
questions.append(question)
example_sms = "%s" % (questionnaire.form_code)
example_sms += get_example_sms(fields)
template = 'project/questionnaire_preview.html' if sms_preview else 'project/questionnaire_preview_list.html'
return render_to_response(
template, {
"questions": questions,
'questionnaire_code': questionnaire.form_code,
'project': questionnaire,
'project_links': project_links,
'is_quota_reached': is_quota_reached(request),
'example_sms': example_sms,
'org_number': get_organization_telephone_number(request)
},
context_instance=RequestContext(request))
def edit_subject_questionnaire(request, entity_type=None):
# edit subject type questionnaire view
manager = get_database_manager(request.user)
if entity_type is None:
return HttpResponseRedirect(reverse(all_subject_types))
form_model = get_form_model_by_entity_type(manager, [entity_type.lower()])
if form_model is None:
form_model = get_form_model_by_code(manager, REGISTRATION_FORM_CODE)
fields = form_model.fields
existing_questions = json.dumps(fields, default=field_to_json)
return render_to_response('entity/questionnaire.html', {
'existing_questions':
repr(existing_questions),
'questionnaire_code':
form_model.form_code,
'language':
form_model.activeLanguages[0],
'entity_type':
entity_type,
'is_pro_sms':
get_organization(request).is_pro_sms,
'post_url':
reverse(save_questionnaire),
'unique_id_types':
json.dumps([{
"name": unique_id_type.capitalize(),
"value": unique_id_type
} for unique_id_type in get_unique_id_types(manager)
if unique_id_type != entity_type]),
},
context_instance=RequestContext(request))
def subject_registration_form_preview(request,
project_id=None,
entity_type=None):
manager = get_database_manager(request.user)
questionnaire = Project.get(manager, project_id)
dashboard_page = settings.HOME_PAGE + "?deleted=true"
if questionnaire.is_void():
return HttpResponseRedirect(dashboard_page)
if not entity_type:
entity_type = questionnaire.entity_type[0]
if request.method == "GET":
fields, project_links, questions, registration_questionnaire = _get_registration_form(
manager, questionnaire, entity_type)
example_sms = get_example_sms_message(
fields, registration_questionnaire.form_code)
return render_to_response(
'project/questionnaire_preview_list.html', {
"questions": questions,
'questionnaire_code': registration_questionnaire.form_code,
'project': questionnaire,
'project_links': project_links,
'is_quota_reached': is_quota_reached(request),
'example_sms': example_sms,
'org_number': get_organization_telephone_number(request)
},
context_instance=RequestContext(request))
def my_poll_recipients_count(request, project_id):
dbm = get_database_manager(request.user)
questionnaire = Project.get(dbm, project_id)
contact_dict = _get_poll_recipients(dbm, questionnaire)
return HttpResponse(content_type='application/json',
content=json.dumps(
{'my_poll_recipients': contact_dict}))
def edit_my_subject_questionnaire(request, project_id, entity_type=None):
manager = get_database_manager(request.user)
questionnaire = Project.get(manager, project_id)
if not entity_type:
entity_type = questionnaire.entity_type[0]
project_links = get_project_link(questionnaire, entity_type)
dashboard_page = settings.HOME_PAGE + "?deleted=true"
if questionnaire.is_void():
return HttpResponseRedirect(dashboard_page)
reg_form = _get_subject_form_model(manager, entity_type)
if reg_form is None:
reg_form = form_model.get_form_model_by_code(manager,
REGISTRATION_FORM_CODE)
fields = reg_form.fields
existing_questions = json.dumps(fields, default=field_to_json)
subject = get_entity_type_info(entity_type, manager=manager)
return render_to_response('project/subject_questionnaire.html', {
'project': questionnaire,
'entity_type': entity_type,
'project_links': project_links,
'is_quota_reached': is_quota_reached(request),
'existing_questions': repr(existing_questions),
'questionnaire_code': reg_form.form_code,
'language': reg_form.activeLanguages[0],
'project_id': questionnaire.id,
'subject': subject,
'post_url': reverse(subject_save_questionnaire)
},
context_instance=RequestContext(request))
def post(self, request, *args, **kwargs):
parser_dict = {
'.xls': XlsDatasenderParser,
'.xlsx': XlsxDataSenderParser
}
manager = get_database_manager(request.user)
file_extension = os.path.splitext(request.GET["qqfile"])[1]
parser = parser_dict.get(file_extension, None)
is_update = request.GET.get('is_update') == 'true'
error_message, failure_imports, success_message, successful_imports = import_module.import_data(
request, manager, default_parser=parser, is_update=is_update)
imported_data_senders = parse_successful_imports(successful_imports)
self._convert_anonymous_submissions_to_registered(
imported_data_senders, manager)
self.update_activity_log(request, successful_imports)
transaction.commit(
) #Mandatory for manually managed transaction blocks. Here it won't save anything
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 __init__(self, *args, **kwargs):
request = kwargs.pop("request", None)
assert request is not None
forms.Form.__init__(self, *args, **kwargs)
org_id = request.user.get_profile().org_id
users_rs = NGOUserProfile.objects.select_related().\
extra(select={'lower_username': '******'}).\
filter(org_id=org_id).order_by("lower_username")
all_users = [("", _("All Users"))]
all_users.extend([(user.user.id,
"%s %s" % (user.user.first_name.capitalize(),
user.user.last_name.capitalize()))
for user in users_rs])
self.fields["user"].choices = all_users
project_choices = [("", _("All Projects"))]
projects = get_all_projects(get_database_manager(request.user))
project_choices.extend(
sorted([(prj["value"]["name"], prj["value"]["name"].capitalize())
for prj in projects],
key=itemgetter(1, 0)))
self.fields["project"].choices = project_choices
def post(self, request, *args, **kwargs):
manager = get_database_manager(request.user)
questionnaires = self._get_projects(manager, request)
projects_name = Set()
for questionnaire in questionnaires:
for id in data_sender_short_codes(request, manager):
questionnaire.associate_data_sender_to_project(manager, id)
projects_name.add(questionnaire.name.capitalize())
ids = request.POST["ids"].split(';')
if len(ids):
UserActivityLog().log(request,
action=ADDED_DATA_SENDERS_TO_PROJECTS,
detail=json.dumps({
"Unique ID":
"[%s]" % ", ".join(ids),
"Projects":
"[%s]" % ", ".join(projects_name)
}))
return HttpResponse(
json.dumps({
"success":
True,
"message":
_("The Data Sender(s) are added to Questionnaire(s) successfully"
)
}))
def all_subject_types(request):
manager = get_database_manager(request.user)
subjects_data = load_subject_type_with_projects(manager)
subjects_count = get_subjects_count(manager)
if "deleted_subject" in request.GET.keys():
deleted_subject_error_message = _(
'Sorry. The Identification Number Type you are looking for has been deleted'
)
return render_to_response(
'entity/all_subject_types.html', {
'all_data': subjects_data,
'current_language': translation.get_language(),
'subjects_count': subjects_count,
'is_pro_sms': get_organization(request).is_pro_sms,
'deleted_subject_error_message':
[deleted_subject_error_message],
},
context_instance=RequestContext(request))
else:
return render_to_response(
'entity/all_subject_types.html', {
'all_data': subjects_data,
'is_pro_sms': get_organization(request).is_pro_sms,
'current_language': translation.get_language(),
'subjects_count': subjects_count,
},
context_instance=RequestContext(request))
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}))
def all_subjects(request, subject_type):
manager = get_database_manager(request.user)
form_model = get_form_model_by_entity_type(manager, [subject_type])
if not form_model:
all_subject_types_page = '/entity/subjects/' + "?deleted_subject=true"
return HttpResponseRedirect(all_subject_types_page)
else:
header_dict = header_fields(form_model)
form_model = get_form_model_by_entity_type(manager, [subject_type])
return render_to_response(
'entity/all_subjects.html', {
'subject_headers': header_dict,
'current_language': translation.get_language(),
'entity_type': subject_type,
'questions': form_model.fields,
'form_code': form_model.form_code,
'is_pro_sms': get_organization(request).is_pro_sms,
'links': {
'create_subject':
reverse("create_subject", args=(subject_type, )) +
"?web_view=True",
'edit_subject_registration_form':
reverse("edit_subject_questionnaire",
args=(subject_type, ))
}
},
context_instance=RequestContext(request))
def add_or_remove_contact_from_groups(request):
dbm = get_database_manager(request.user)
group_names = json.loads(request.POST['group-names'])
current_group_name = request.POST['current_group_name']
contact_ids = json.loads(request.POST['contact_ids'])
all_selected = json.loads(request.POST['all_selected'])
action = request.POST['action']
success = True
try:
if not all_selected:
_update_group_for_contacts(contact_ids, dbm, group_names, action)
else:
search_query = request.POST['search_query']
contact_ids = _get_reporter_ids_for_group_name(
dbm, current_group_name, search_query)
_update_group_for_contacts(contact_ids, dbm, group_names, action)
message = 'The Contact(s) are added to Group(s) successfully.' if action == 'add' else 'The Contact(s) are removed from Group(s) successfully.'
except Exception as e:
# log exception
message = ugettext('Failed to add in to group.')
success = False
return HttpResponse(content=json.dumps({
'success': success,
'message': ugettext(message)
}),
content_type='application/json')
def check_submissions_status(request, project_uuid):
req_id_version_array = json.loads(request.POST['submissions'])
outdated_ids = []
insync_ids = []
req_id_version_dict = {}
manager = get_database_manager(request.user)
for single_dict in req_id_version_array:
req_id_version_dict[single_dict['id']] = single_dict['rev']
req_ids = req_id_version_dict.keys()
rows = manager.load_all_rows_in_view(
"survey_response_by_survey_response_id", keys=req_ids)
id_version_dict = {
r.value['_id']: r.value['_rev']
for r in rows if not r.value['void']
}
req_ids_set = Set(req_ids)
ids = id_version_dict.keys()
ids_not_found = list(req_ids_set.difference(ids))
ids_found = req_ids_set.intersection(ids)
for id_found in ids_found:
if req_id_version_dict[id_found] == id_version_dict[id_found]:
insync_ids.append(id_found)
else:
outdated_ids.append(id_found)
return response_json_cors({
'both': insync_ids,
'server-deleted': ids_not_found,
'outdated': outdated_ids
})