def toggle_diff(request, domain):
params = json_request(request.GET)
other_domain = params.get('domain')
diff = []
if Domain.get_by_name(other_domain):
diff = [{
'slug': t.slug,
'label': t.label,
'url': reverse(ToggleEditView.urlname, args=[t.slug]),
'tag_name': _('Preview'),
'tag_css_class': 'default',
'tag_index': -1,
} for t in feature_previews.all_previews()
if _can_copy_toggle(t, request.domain, other_domain)]
diff.extend([{
'slug': t.slug,
'label': t.label,
'url': reverse(ToggleEditView.urlname, args=[t.slug]),
'tag_name': t.tag.name,
'tag_css_class': t.tag.css_class,
'tag_index': t.tag.index,
} for t in toggles.all_toggles()
if _can_copy_toggle(t, request.domain, other_domain)])
diff.sort(key=lambda x: (x['tag_index'], x['label']))
return json_response(diff)
def create_export_filter(request, domain, export_type='form'):
from corehq.apps.reports.fields import FilterUsersField
app_id = request.GET.get('app_id', None)
group, users = get_group_params(domain, **json_request(request.GET))
user_filters, use_user_filters = FilterUsersField.get_user_filter(request)
if export_type == 'case':
if user_filters and use_user_filters:
users_matching_filter = map(
lambda x: x.get('user_id'),
get_all_users_by_domain(domain,
user_filter=user_filters,
simplified=True))
filter = SerializableFunction(case_users_filter,
users=users_matching_filter)
else:
filter = SerializableFunction(case_group_filter, group=group)
else:
filter = SerializableFunction(instances) & SerializableFunction(
app_export_filter, app_id=app_id)
filter &= SerializableFunction(datespan_export_filter,
datespan=request.datespan)
if user_filters and use_user_filters:
users_matching_filter = map(
lambda x: x.get('user_id'),
get_all_users_by_domain(domain,
user_filter=user_filters,
simplified=True))
filter &= SerializableFunction(users_filter,
users=users_matching_filter)
else:
filter &= SerializableFunction(group_filter, group=group)
return filter
def create_export_filter(request, domain, export_type='form'):
from corehq.apps.reports.filters.users import UserTypeFilter
app_id = request.GET.get('app_id', None)
group, users = get_group_params(domain, **json_request(request.GET))
user_filters, use_user_filters = UserTypeFilter.get_user_filter(request)
if export_type == 'case':
if user_filters and use_user_filters:
filtered_users = users_matching_filter(domain, user_filters)
filter = SerializableFunction(case_users_filter,
users=filtered_users)
else:
filter = SerializableFunction(case_group_filter, group=group)
else:
filter = SerializableFunction(app_export_filter, app_id=app_id)
datespan = request.datespan
if datespan.is_valid():
datespan.set_timezone(get_timezone(request.couch_user, domain))
filter &= SerializableFunction(datespan_export_filter, datespan=datespan)
if user_filters and use_user_filters:
filtered_users = users_matching_filter(domain, user_filters)
filter &= SerializableFunction(users_filter, users=filtered_users)
else:
filter &= SerializableFunction(group_filter, group=group)
return filter
def __init__(self, request, base_context=None, domain=None, **kwargs):
if not self.name or not self.section_name or self.slug is None or not self.dispatcher:
raise NotImplementedError(
"Missing a required parameter: (name: %(name)s, section_name: %(section_name)s,"
" slug: %(slug)s, dispatcher: %(dispatcher)s" %
dict(name=self.name,
section_name=self.section_name,
slug=self.slug,
dispatcher=self.dispatcher))
from corehq.apps.reports.dispatcher import ReportDispatcher
if isinstance(self.dispatcher, ReportDispatcher):
raise ValueError(
"Class property dispatcher should point to a subclass of ReportDispatcher."
)
self.request = request
self.request_params = json_request(
self.request.GET if self.request.method ==
'GET' else self.request.POST)
self.domain = normalize_domain_name(domain)
self.context = base_context or {}
self._update_initial_context()
self.is_rendered_as_email = False # setting this to true in email_response
self.override_template = "reports/async/email_report.html"
def post(self, request, *args, **kwargs):
request_json = json_request(request.POST)
doc = request_json.get('doc')
CommCareBuildConfig.get_db().save_doc(doc)
CommCareBuildConfig.clear_local_cache()
messages.success(request, "Your changes have been saved")
return HttpResponseRedirect(self.page_url)
def create_export_filter(request, domain, export_type='form'):
request_obj = request.POST if request.method == 'POST' else request.GET
from corehq.apps.reports.filters.users import UserTypeFilter
app_id = request_obj.get('app_id', None)
user_filters, use_user_filters = UserTypeFilter.get_user_filter(request)
use_user_filters &= bool(user_filters)
group = None if use_user_filters else get_group(**json_request(request_obj))
if export_type == 'case':
if use_user_filters:
groups = [g.get_id for g in Group.get_case_sharing_groups(domain)]
filtered_users = users_matching_filter(domain, user_filters)
filter = SerializableFunction(case_users_filter,
users=filtered_users,
groups=groups)
else:
filter = SerializableFunction(case_group_filter, group=group)
else:
filter = SerializableFunction(app_export_filter, app_id=app_id)
datespan = request.datespan
if datespan.is_valid():
datespan.set_timezone(get_timezone_for_user(request.couch_user, domain))
filter &= SerializableFunction(datespan_export_filter, datespan=datespan)
if use_user_filters:
filtered_users = users_matching_filter(domain, user_filters)
filter &= SerializableFunction(users_filter,
users=filtered_users)
else:
filter &= SerializableFunction(group_filter, group=group)
return filter
def create_export_filter(request, domain, export_type='form'):
request_obj = request.POST if request.method == 'POST' else request.GET
from corehq.apps.reports.filters.users import UserTypeFilter
app_id = request_obj.get('app_id', None)
user_filters, use_user_filters = UserTypeFilter.get_user_filter(request)
use_user_filters &= bool(user_filters)
group = None if use_user_filters else get_group(
**json_request(request_obj))
if export_type == 'case':
if use_user_filters:
groups = [g.get_id for g in Group.get_case_sharing_groups(domain)]
filtered_users = users_matching_filter(domain, user_filters)
filter = SerializableFunction(case_users_filter,
users=filtered_users,
groups=groups)
else:
filter = SerializableFunction(case_group_filter, group=group)
else:
filter = SerializableFunction(app_export_filter, app_id=app_id)
datespan = request.datespan
if datespan.is_valid():
datespan.set_timezone(
get_timezone_for_user(request.couch_user, domain))
filter &= SerializableFunction(datespan_export_filter,
datespan=datespan)
if use_user_filters:
filtered_users = users_matching_filter(domain, user_filters)
filter &= SerializableFunction(users_filter, users=filtered_users)
else:
filter &= SerializableFunction(group_filter, group=group)
return filter
def create_export_filter(request, domain, export_type='form'):
from corehq.apps.reports.fields import FilterUsersField
app_id = request.GET.get('app_id', None)
group, users = get_group_params(domain, **json_request(request.GET))
user_filters, use_user_filters = FilterUsersField.get_user_filter(request)
if export_type == 'case':
if user_filters and use_user_filters:
users_matching_filter = map(lambda x: x.get('user_id'), get_all_users_by_domain(domain,
user_filter=user_filters, simplified=True))
filter = SerializableFunction(case_users_filter, users=users_matching_filter)
else:
filter = SerializableFunction(case_group_filter, group=group)
else:
filter = SerializableFunction(app_export_filter, app_id=app_id)
filter &= SerializableFunction(datespan_export_filter, datespan=request.datespan)
if user_filters and use_user_filters:
users_matching_filter = map(lambda x: x.get('user_id'), get_all_users_by_domain(domain,
user_filter=user_filters, simplified=True))
filter &= SerializableFunction(users_filter, users=users_matching_filter)
else:
filter &= SerializableFunction(group_filter, group=group)
return filter
def edit_app_translations(request, domain, app_id):
params = json_request(request.POST)
lang = params.get('lang')
translations = params.get('translations')
app = get_app(domain, app_id)
app.set_translations(lang, translations)
response = {}
app.save(response)
return json_response(response)
def export_data(req, domain):
"""
Download all data for a couchdbkit model
"""
try:
export_tag = json.loads(req.GET.get("export_tag", "null") or "null")
except ValueError:
return HttpResponseBadRequest()
group, users = util.get_group_params(domain, **json_request(req.GET))
include_errors = string_to_boolean(req.GET.get("include_errors", False))
kwargs = {
"format": req.GET.get("format", Format.XLS_2007),
"previous_export_id": req.GET.get("previous_export", None),
"filename": export_tag,
"use_cache": string_to_boolean(req.GET.get("use_cache", "True")),
"max_column_size": int(req.GET.get("max_column_size", 2000)),
"separator": req.GET.get("separator", "|")
}
user_filter, _ = UserTypeFilter.get_user_filter(req)
if user_filter:
filtered_users = users_matching_filter(domain, user_filter)
def _ufilter(user):
try:
return user['form']['meta']['userID'] in filtered_users
except KeyError:
return False
filter = _ufilter
else:
filter = SerializableFunction(util.group_filter, group=group)
errors_filter = instances if not include_errors else None
kwargs['filter'] = couchexport.util.intersect_functions(
filter, errors_filter)
if kwargs['format'] == 'raw':
resp = export_raw_data([domain, export_tag], filename=export_tag)
else:
try:
resp = export_data_shared([domain, export_tag], **kwargs)
except CouchExportException as e:
return HttpResponseBadRequest(e)
if resp:
return resp
else:
messages.error(
req,
"Sorry, there was no data found for the tag '%s'." % export_tag)
next = req.GET.get("next", "")
if not next:
next = export.ExcelExportReport.get_url(domain=domain)
return HttpResponseRedirect(next)
def toggle_diff(request, domain):
params = json_request(request.GET)
other_domain = params.get('domain')
diff = []
if Domain.get_by_name(other_domain):
diff = [{'slug': t.slug, 'label': t.label, 'url': reverse(ToggleEditView.urlname, args=[t.slug])}
for t in feature_previews.all_previews() + all_toggles()
if t.enabled(request.domain, NAMESPACE_DOMAIN) and not t.enabled(other_domain, NAMESPACE_DOMAIN)]
diff.sort(key=lambda x: x['label'])
return json_response(diff)
def edit_report_module(request, domain, app_id, module_unique_id):
"""
Overwrite module case details. Only overwrites components that have been
provided in the request. Components are short, long, filter, parent_select,
and sort_elements.
"""
params = json_request(request.POST)
app = get_app(domain, app_id)
try:
module = app.get_module_by_unique_id(module_unique_id)
except ModuleNotFoundException:
# temporary fallback
module = app.get_module(module_unique_id)
assert isinstance(module, ReportModule)
module.name = params['name']
try:
module.report_configs = [
ReportAppConfig.wrap(spec) for spec in params['reports']
]
except Exception:
notify_exception(
request,
message="Something went wrong while editing report modules",
details={
'domain': domain,
'app_id': app_id,
})
return HttpResponseBadRequest(
_("There was a problem processing your request."))
if app.enable_module_filtering:
module['module_filter'] = request.POST.get('module_filter')
module.media_image.update(params['multimedia']['mediaImage'])
module.media_audio.update(params['multimedia']['mediaAudio'])
try:
app.save()
except Exception:
notify_exception(
request,
message=
"Something went wrong while saving app {} while editing report modules"
.format(app_id),
details={
'domain': domain,
'app_id': app_id,
})
return HttpResponseBadRequest(
_("There was a problem processing your request."))
get_uuids_by_instance_id.clear(domain)
return json_response('success')
def get_app_ui_translations(request, domain):
params = json_request(request.GET)
lang = params.get('lang', 'en')
key = params.get('key', None)
one = params.get('one', False)
translations = Translation.get_translations(lang, key, one)
if isinstance(translations, dict):
translations = {k: v for k, v in translations.items()
if not id_strings.is_custom_app_string(k)
and '=' not in k}
return json_response(translations)
def get_app_ui_translations(request, domain):
params = json_request(request.GET)
lang = params.get("lang", "en")
key = params.get("key", None)
one = params.get("one", False)
translations = Translation.get_translations(lang, key, one)
if isinstance(translations, dict):
translations = {
k: v for k, v in translations.items() if not id_strings.is_custom_app_string(k) and "=" not in k
}
return json_response(translations)
def get_app_ui_translations(request, domain):
params = json_request(request.GET)
lang = params.get('lang', 'en')
key = params.get('key', None)
one = params.get('one', False)
translations = Translation.get_translations(lang, key, one)
if isinstance(translations, dict):
translations = {k: v for k, v in translations.items()
if not id_strings.is_custom_app_string(k)
and '=' not in k}
return json_response(translations)
def export_data(req, domain):
"""
Download all data for a couchdbkit model
"""
try:
export_tag = json.loads(req.GET.get("export_tag", "null") or "null")
except ValueError:
return HttpResponseBadRequest()
group, users = util.get_group_params(domain, **json_request(req.GET))
include_errors = string_to_boolean(req.GET.get("include_errors", False))
kwargs = {
"format": req.GET.get("format", Format.XLS_2007),
"previous_export_id": req.GET.get("previous_export", None),
"filename": export_tag,
"use_cache": string_to_boolean(req.GET.get("use_cache", "True")),
"max_column_size": int(req.GET.get("max_column_size", 2000)),
"separator": req.GET.get("separator", "|"),
}
user_filter, _ = UserTypeFilter.get_user_filter(req)
if user_filter:
filtered_users = users_matching_filter(domain, user_filter)
def _ufilter(user):
try:
return user["form"]["meta"]["userID"] in filtered_users
except KeyError:
return False
filter = _ufilter
else:
filter = SerializableFunction(util.group_filter, group=group)
errors_filter = instances if not include_errors else None
kwargs["filter"] = couchexport.util.intersect_functions(filter, errors_filter)
if kwargs["format"] == "raw":
resp = export_raw_data([domain, export_tag], filename=export_tag)
else:
try:
resp = export_data_shared([domain, export_tag], **kwargs)
except CouchExportException as e:
return HttpResponseBadRequest(e)
if resp:
return resp
else:
messages.error(req, "Sorry, there was no data found for the tag '%s'." % export_tag)
next = req.GET.get("next", "")
if not next:
next = export.ExcelExportReport.get_url(domain=domain)
return HttpResponseRedirect(next)
def edit(request, template="translations/edit.html"):
params = json_request(request.GET)
doc_id = params.get('doc_id')
lang = params.get('lang')
trans = TranslationMixin.get(doc_id)
validate_trans_doc(trans)
return render(request, template, {
"translations_json": json.dumps(trans.translations[lang]),
"doc_id": doc_id,
"lang": lang
})
def export_data(req, domain):
"""
Download all data for a couchdbkit model
"""
try:
export_tag = json.loads(req.GET.get("export_tag", "null") or "null")
except ValueError:
return HttpResponseBadRequest()
group, users = util.get_group_params(domain, **json_request(req.GET))
include_errors = string_to_boolean(req.GET.get("include_errors", False))
kwargs = {"format": req.GET.get("format", Format.XLS_2007),
"previous_export_id": req.GET.get("previous_export", None),
"filename": export_tag,
"use_cache": string_to_boolean(req.GET.get("use_cache", "True")),
"max_column_size": int(req.GET.get("max_column_size", 2000)),
"separator": req.GET.get("separator", "|")}
user_filter, _ = FilterUsersField.get_user_filter(req)
if user_filter:
users_matching_filter = map(lambda x: x.get('user_id'), get_all_users_by_domain(domain,
user_filter=user_filter, simplified=True))
def _ufilter(user):
try:
return user['form']['meta']['userID'] in users_matching_filter
except KeyError:
return False
filter = _ufilter
else:
filter = SerializableFunction(util.group_filter, group=group)
errors_filter = instances if not include_errors else None
kwargs['filter'] = couchexport.util.intersect_functions(filter, errors_filter)
if kwargs['format'] == 'raw':
resp = export_raw_data([domain, export_tag], filename=export_tag)
else:
try:
resp = export_data_shared([domain,export_tag], **kwargs)
except UnsupportedExportFormat as e:
return HttpResponseBadRequest(e)
if resp:
return resp
else:
messages.error(req, "Sorry, there was no data found for the tag '%s'." % export_tag)
next = req.GET.get("next", "")
if not next:
next = export.ExcelExportReport.get_url(domain)
return HttpResponseRedirect(next)
def edit(request, template="translations/edit.html"):
params = json_request(request.GET)
doc_id = params.get('doc_id')
lang = params.get('lang')
trans = TranslationMixin.get(doc_id)
validate_trans_doc(trans)
return render(
request, template, {
"translations_json": json.dumps(trans.translations[lang]),
"doc_id": doc_id,
"lang": lang
})
def query_dict_to_dict(query_dict, domain):
"""
Transform the given QueryDict to a normal dict where each value has been
converted from a string to a dict (if the value is JSON).
Also add the domain to the dict.
:param query_dict: a QueryDict
:param domain:
:return: a dict
"""
request_dict = json_request(query_dict)
request_dict['domain'] = domain
return request_dict
def query_dict_to_dict(query_dict, domain):
"""
Transform the given QueryDict to a normal dict where each value has been
converted from a string to a dict (if the value is JSON).
Also add the domain to the dict.
:param query_dict: a QueryDict
:param domain:
:return: a dict
"""
request_dict = json_request(query_dict)
request_dict['domain'] = domain
return request_dict
def toggle_diff(request, domain):
params = json_request(request.GET)
other_domain = params.get('domain')
diff = []
if Domain.get_by_name(other_domain):
diff = [{
'slug': t.slug,
'label': t.label,
'url': reverse(ToggleEditView.urlname, args=[t.slug])
} for t in feature_previews.all_previews() + all_toggles()
if t.enabled(request.domain, NAMESPACE_DOMAIN)
and not t.enabled(other_domain, NAMESPACE_DOMAIN)]
diff.sort(key=lambda x: x['label'])
return json_response(diff)
def edit_report_module(request, domain, app_id, module_unique_id):
"""
Overwrite module case details. Only overwrites components that have been
provided in the request. Components are short, long, filter, parent_select,
and sort_elements.
"""
params = json_request(request.POST)
app = get_app(domain, app_id)
try:
module = app.get_module_by_unique_id(module_unique_id)
except ModuleNotFoundException:
# temporary fallback
module = app.get_module(module_unique_id)
assert isinstance(module, ReportModule)
module.name = params['name']
try:
module.report_configs = [ReportAppConfig.wrap(spec) for spec in params['reports']]
except Exception:
notify_exception(
request,
message="Something went wrong while editing report modules",
details={'domain': domain, 'app_id': app_id, }
)
return HttpResponseBadRequest(_("There was a problem processing your request."))
if app.enable_module_filtering:
module['module_filter'] = request.POST.get('module_filter')
module.media_image.update(params['multimedia']['mediaImage'])
module.media_audio.update(params['multimedia']['mediaAudio'])
if 'name_enum' in params:
name_enum = json.loads(request.POST.get("name_enum"))
module.name_enum = [MappingItem(i) for i in name_enum]
try:
app.save()
except Exception:
notify_exception(
request,
message="Something went wrong while saving app {} while editing report modules".format(app_id),
details={'domain': domain, 'app_id': app_id, }
)
return HttpResponseBadRequest(_("There was a problem processing your request."))
get_uuids_by_instance_id.clear(domain)
return json_response('success')
def edit_app_ui_translations(request, domain, app_id):
params = json_request(request.POST)
lang = params.get('lang')
translations = params.get('translations')
app = get_app(domain, app_id)
# Workaround for https://github.com/dimagi/commcare-hq/pull/10951#issuecomment-203978552
# auto-fill UI translations might have modules.m0 in the update originating from popular-translations docs
# since module.m0 is not a UI string, don't update modules.m0 in UI translations
translations.pop('modules.m0', None)
app.set_translations(lang, translations)
app.save(response_json={}) # Updates the app version without updating app properties
return json_response({})
def edit_report_module(request, domain, app_id, module_id):
"""
Overwrite module case details. Only overwrites components that have been
provided in the request. Components are short, long, filter, parent_select,
and sort_elements.
"""
params = json_request(request.POST)
app = get_app(domain, app_id)
module = app.get_module(module_id)
assert isinstance(module, ReportModule)
module.name = params['name']
module.report_configs = [ReportAppConfig.wrap(spec) for spec in params['reports']]
app.save()
return json_response('success')
def edit_app_ui_translations(request, domain, app_id):
params = json_request(request.POST)
lang = params.get("lang")
translations = params.get("translations")
app = get_app(domain, app_id)
# Workaround for https://github.com/dimagi/commcare-hq/pull/10951#issuecomment-203978552
# auto-fill UI translations might have modules.m0 in the update originating from popular-translations docs
# since module.m0 is not a UI string, don't update modules.m0 in UI translations
translations.pop("modules.m0", None)
app.set_translations(lang, translations)
response = {}
app.save(response)
return json_response(response)
def set_translations(request):
params = json_request(request.POST)
doc_id = params.get('doc_id')
lang = params.get('lang')
translations = params.get('translations')
trans = TranslationMixin.get(doc_id)
trans.set_translations(lang, translations)
resp = {}
try:
trans.save(response_json=resp)
except Exception:
trans.save()
return json_response(resp)
def set_translations(request):
params = json_request(request.POST)
doc_id = params.get('doc_id')
lang = params.get('lang')
translations = params.get('translations')
trans = TranslationMixin.get(doc_id)
trans.set_translations(lang, translations)
resp = {}
try:
trans.save(response_json=resp)
except Exception:
trans.save()
return json_response(resp)
def cases_json(request, domain):
def query(stale="ok", **kwargs):
subs = [dict(
userID = r['key'][1],
username = r['key'][2],
deviceID = r['key'][3],
submissions = r['value']['count'],
start = r['value']['start'].split('T')[0],
end = r['value']['end' ].split('T')[0]
) for r in get_db().view('cleanup/case_submissions',
startkey=[domain],
endkey=[domain, {}],
group=True,
# stale=stale
)]
subs.sort(key=lambda sub: (sub['userID'], sub['end']))
# Try and help identify lost devices
latest_start = defaultdict(lambda: None)
for sub in subs:
latest_start[sub['userID']] = max(sub['start'], latest_start[sub['userID']])
for sub in subs:
if sub['end'] < latest_start[sub['userID']]:
sub['old'] = True
else:
sub['old'] = False
# show the number of cases made by these xforms
# for sub in subs:
# cases = _get_cases(_get_submissions(domain, [sub]))
# sub['cases'] = len([None for case in cases if not case.closed])
open_cases = CommCareCase.view('hqcase/open_cases', startkey=[domain], endkey=[domain, {}], reduce=False, include_docs=True).all()
xform_ids = [case.xform_ids[0] for case in open_cases]
case_count = defaultdict(int)
for xform_id in xform_ids:
xform = XFormInstance.get(xform_id)
meta = xform.form['meta']
case_count[(meta['userID'], meta['username'], meta['deviceID'])] += 1
for sub in subs:
sub['cases'] = case_count[(sub['userID'], sub['username'], sub['deviceID'])]
return json_response({
"results": subs,
"total": len(subs),
})
return query(**json_request(request.GET))
def edit_report_module(request, domain, app_id, module_id):
"""
Overwrite module case details. Only overwrites components that have been
provided in the request. Components are short, long, filter, parent_select,
and sort_elements.
"""
params = json_request(request.POST)
app = get_app(domain, app_id)
module = app.get_module(module_id)
assert isinstance(module, ReportModule)
module.name = params['name']
module.report_configs = [ReportAppConfig.wrap(spec) for spec in params['reports']]
if (feature_previews.MODULE_FILTER.enabled(domain) and
app.enable_module_filtering):
module['module_filter'] = request.POST.get('module_filter')
module.media_image.update(params['multimedia']['mediaImage'])
module.media_audio.update(params['multimedia']['mediaAudio'])
app.save()
return json_response('success')
def __init__(self, request, base_context=None, *args, **kwargs):
if not self.name or not self.section_name or self.slug is None or not self.dispatcher:
raise NotImplementedError("Missing a required parameter: (name: %(name)s, section_name: %(section_name)s,"
" slug: %(slug)s, dispatcher: %(dispatcher)s" % dict(
name=self.name,
section_name=self.section_name,
slug=self.slug,
dispatcher=self.dispatcher
))
from corehq.apps.reports.dispatcher import ReportDispatcher
if isinstance(self.dispatcher, ReportDispatcher):
raise ValueError("Class property dispatcher should point to a subclass of ReportDispatcher.")
self.request = request
self.request_params = json_request(self.request.GET)
self.domain = kwargs.get('domain')
self.context = base_context or {}
self._update_initial_context()
def __init__(self, request, base_context=None, domain=None, **kwargs):
if not self.name or not self.section_name or self.slug is None or not self.dispatcher:
raise NotImplementedError(
"Missing a required parameter: (name: %(name)s, section_name: %(section_name)s,"
" slug: %(slug)s, dispatcher: %(dispatcher)s"
% dict(name=self.name, section_name=self.section_name, slug=self.slug, dispatcher=self.dispatcher)
)
from corehq.apps.reports.dispatcher import ReportDispatcher
if isinstance(self.dispatcher, ReportDispatcher):
raise ValueError("Class property dispatcher should point to a subclass of ReportDispatcher.")
self.request = request
self.request_params = json_request(self.request.GET if self.request.method == "GET" else self.request.POST)
self.domain = normalize_domain_name(domain)
self.context = base_context or {}
self._update_initial_context()
self.is_rendered_as_email = False # setting this to true in email_response
self.override_template = "reports/async/email_report.html"
def query_dict_to_dict(query_dict, domain, string_type_params):
"""
Transform the given QueryDict to a normal dict where each value has been
converted from a string to a dict (if the value is JSON). params with values 'true'
or 'false' or numbers are casted to respective datatypes, unless the key is specified in string_type_params
Also add the domain to the dict.
:param query_dict: a QueryDict
:param domain:
:string_type_params: list of params that should not be autocasted to boolean/numbers
:return: a dict
"""
request_dict = json_request(query_dict)
request_dict['domain'] = domain
# json.loads casts strings 'true'/'false' to booleans, so undo it
for key in string_type_params:
u_key = six.text_type(key) # QueryDict's key/values are unicode strings
if u_key in query_dict:
request_dict[key] = query_dict[u_key] # json_request converts keys to strings
return request_dict
def query_dict_to_dict(query_dict, domain, string_type_params):
"""
Transform the given QueryDict to a normal dict where each value has been
converted from a string to a dict (if the value is JSON). params with values 'true'
or 'false' or numbers are casted to respective datatypes, unless the key is specified in string_type_params
Also add the domain to the dict.
:param query_dict: a QueryDict
:param domain:
:string_type_params: list of params that should not be autocasted to boolean/numbers
:return: a dict
"""
request_dict = json_request(query_dict)
request_dict['domain'] = domain
# json.loads casts strings 'true'/'false' to booleans, so undo it
for key in string_type_params:
u_key = six.text_type(key) # QueryDict's key/values are unicode strings
if u_key in query_dict:
request_dict[key] = query_dict[u_key] # json_request converts keys to strings
return request_dict
def edit_report_module(request, domain, app_id, module_id):
"""
Overwrite module case details. Only overwrites components that have been
provided in the request. Components are short, long, filter, parent_select,
and sort_elements.
"""
params = json_request(request.POST)
app = get_app(domain, app_id)
module = app.get_module(module_id)
assert isinstance(module, ReportModule)
module.name = params['name']
try:
module.report_configs = [ReportAppConfig.wrap(spec) for spec in params['reports']]
except Exception:
notify_exception(
request,
message="Something went wrong while editing report modules",
details={'domain': domain, 'app_id': app_id, }
)
return HttpResponseBadRequest(_("There was a problem processing your request."))
if (feature_previews.MODULE_FILTER.enabled(domain) and
app.enable_module_filtering):
module['module_filter'] = request.POST.get('module_filter')
module.media_image.update(params['multimedia']['mediaImage'])
module.media_audio.update(params['multimedia']['mediaAudio'])
try:
app.save()
except Exception:
notify_exception(
request,
message="Something went wrong while saving app {} while editing report modules".format(app_id),
details={'domain': domain, 'app_id': app_id, }
)
return HttpResponseBadRequest(_("There was a problem processing your request."))
return json_response('success')
def _export_report(self, emails, title):
from corehq.apps.reports.standard.deployments import ApplicationStatusReport
for report_config in self.configs:
mock_request = HttpRequest()
mock_request.couch_user = self.owner
mock_request.user = self.owner.get_django_user()
mock_request.domain = self.domain
mock_request.couch_user.current_domain = self.domain
mock_request.couch_user.language = self.language
mock_request.method = 'GET'
mock_request.bypass_two_factor = True
mock_query_string_parts = [
report_config.query_string, 'filterSet=true'
]
mock_request.GET = QueryDict('&'.join(mock_query_string_parts))
request_data = vars(mock_request)
request_data['couch_user'] = mock_request.couch_user.userID
if report_config.report_slug != ApplicationStatusReport.slug:
# ApplicationStatusReport doesn't have date filter
date_range = report_config.get_date_range()
start_date = datetime.strptime(date_range['startdate'],
'%Y-%m-%d')
end_date = datetime.strptime(date_range['enddate'], '%Y-%m-%d')
datespan = DateSpan(start_date, end_date)
request_data['datespan'] = datespan
full_request = {
'request': request_data,
'domain': request_data['domain'],
'context': {},
'request_params': json_request(request_data['GET'])
}
export_all_rows_task(report_config.report, full_request, emails,
title)
def query_dict_to_dict(query_dict, domain, string_type_params):
"""
Transform the given QueryDict to a normal dict where each value has been
converted from a string to a dict (if the value is JSON). params with values 'true'
or 'false' or numbers are casted to respective datatypes, unless the key is specified in string_type_params
Also add the domain to the dict.
:param query_dict: a QueryDict
:param domain:
:string_type_params: list of params that should not be autocasted to boolean/numbers
:return: a dict
"""
request_dict = json_request(query_dict)
request_dict['domain'] = domain
# json.loads casts strings 'true'/'false' to booleans, so undo it
for key in string_type_params:
if key in query_dict:
vals = query_dict.getlist(key)
if len(vals) > 1:
request_dict[key] = vals
else:
request_dict[key] = vals[0]
return request_dict
def edit_module_detail_screens(request, domain, app_id, module_id):
"""
Overwrite module case details. Only overwrites components that have been
provided in the request. Components are short, long, filter, parent_select,
fixture_select and sort_elements.
"""
params = json_request(request.POST)
detail_type = params.get('type')
short = params.get('short', None)
long = params.get('long', None)
tabs = params.get('tabs', None)
filter = params.get('filter', ())
custom_xml = params.get('custom_xml', None)
parent_select = params.get('parent_select', None)
fixture_select = params.get('fixture_select', None)
sort_elements = params.get('sort_elements', None)
persist_case_context = params.get('persistCaseContext', None)
persistent_case_context_xml = params.get('persistentCaseContextXML', None)
use_case_tiles = params.get('useCaseTiles', None)
persist_tile_on_forms = params.get("persistTileOnForms", None)
pull_down_tile = params.get("enableTilePullDown", None)
case_list_lookup = params.get("case_list_lookup", None)
search_properties = params.get("search_properties")
custom_variables = {
'short': params.get("short_custom_variables", None),
'long': params.get("long_custom_variables", None)
}
app = get_app(domain, app_id)
module = app.get_module(module_id)
if detail_type == 'case':
detail = module.case_details
elif detail_type == CAREPLAN_GOAL:
detail = module.goal_details
elif detail_type == CAREPLAN_TASK:
detail = module.task_details
else:
try:
detail = getattr(module, '{0}_details'.format(detail_type))
except AttributeError:
return HttpResponseBadRequest("Unknown detail type '%s'" %
detail_type)
lang = request.COOKIES.get('lang', app.langs[0])
if short is not None:
detail.short.columns = map(DetailColumn.from_json, short)
if persist_case_context is not None:
detail.short.persist_case_context = persist_case_context
detail.short.persistent_case_context_xml = persistent_case_context_xml
if use_case_tiles is not None:
detail.short.use_case_tiles = use_case_tiles
if persist_tile_on_forms is not None:
detail.short.persist_tile_on_forms = persist_tile_on_forms
if pull_down_tile is not None:
detail.short.pull_down_tile = pull_down_tile
if case_list_lookup is not None:
_save_case_list_lookup_params(detail.short, case_list_lookup, lang)
if long is not None:
detail.long.columns = map(DetailColumn.from_json, long)
if tabs is not None:
detail.long.tabs = map(DetailTab.wrap, tabs)
if filter != ():
# Note that we use the empty tuple as the sentinel because a filter
# value of None represents clearing the filter.
detail.short.filter = filter
if custom_xml is not None:
detail.short.custom_xml = custom_xml
if custom_variables['short'] is not None:
try:
etree.fromstring("<variables>{}</variables>".format(
custom_variables['short']))
except etree.XMLSyntaxError as error:
return HttpResponseBadRequest(
"There was an issue with your custom variables: {}".format(
error.message))
detail.short.custom_variables = custom_variables['short']
if custom_variables['long'] is not None:
try:
etree.fromstring("<variables>{}</variables>".format(
custom_variables['long']))
except etree.XMLSyntaxError as error:
return HttpResponseBadRequest(
"There was an issue with your custom variables: {}".format(
error.message))
detail.long.custom_variables = custom_variables['long']
if sort_elements is not None:
detail.short.sort_elements = []
for sort_element in sort_elements:
item = SortElement()
item.field = sort_element['field']
item.type = sort_element['type']
item.direction = sort_element['direction']
item.display[lang] = sort_element['display']
if toggles.SORT_CALCULATION_IN_CASE_LIST.enabled(domain):
item.sort_calculation = sort_element['sort_calculation']
else:
item.sort_calculation = ""
detail.short.sort_elements.append(item)
if parent_select is not None:
module.parent_select = ParentSelect.wrap(parent_select)
if module_case_hierarchy_has_circular_reference(module):
return HttpResponseBadRequest(
_("The case hierarchy contains a circular reference."))
if fixture_select is not None:
module.fixture_select = FixtureSelect.wrap(fixture_select)
if search_properties is not None:
if search_properties.get('properties') is not None:
module.search_config = CaseSearch(
properties=[
CaseSearchProperty.wrap(p)
for p in _update_search_properties(
module, search_properties.get('properties'), lang)
],
relevant=(search_properties.get('relevant')
if search_properties.get('relevant') is not None else
CLAIM_DEFAULT_RELEVANT_CONDITION),
include_closed=bool(search_properties.get('include_closed')),
default_properties=[
DefaultCaseSearchProperty.wrap(p)
for p in search_properties.get('default_properties')
])
resp = {}
app.save(resp)
return json_response(resp)
def request_params(self):
return json_request({})
def send_email_report(self, recipient_emails, domain, report_slug, report_type,
request_data, once, cleaned_data):
"""
Function invokes send_HTML_email to email the html text report.
If the report is too large to fit into email then a download link is
sent via email to download report
:Parameter recipient_list:
list of recipient to whom email is to be sent
:Parameter domain:
domain name
:Parameter report_slug:
report slug
:Parameter report_type:
type of the report
:Parameter request_data:
Dict containing request data
:Parameter once
boolean argument specifying whether the report is once off report
or scheduled report
:Parameter cleaned_data:
Dict containing cleaned data from the submitted form
"""
from corehq.apps.reports.views import _render_report_configs, render_full_report_notification
user_id = request_data['couch_user']
couch_user = CouchUser.get_by_user_id(user_id)
mock_request = HttpRequest()
mock_request.method = 'GET'
mock_request.GET = request_data['GET']
config = ReportConfig()
# see ReportConfig.query_string()
object.__setattr__(config, '_id', 'dummy')
config.name = _("Emailed report")
config.report_type = report_type
config.report_slug = report_slug
config.owner_id = user_id
config.domain = domain
config.start_date = request_data['datespan'].startdate.date()
if request_data['datespan'].enddate:
config.date_range = 'range'
config.end_date = request_data['datespan'].enddate.date()
else:
config.date_range = 'since'
GET = dict(six.iterlists(request_data['GET']))
exclude = ['startdate', 'enddate', 'subject', 'send_to_owner', 'notes', 'recipient_emails']
filters = {}
for field in GET:
if field not in exclude:
filters[field] = GET.get(field)
config.filters = filters
subject = cleaned_data['subject'] or _("Email report from CommCare HQ")
try:
content = _render_report_configs(
mock_request, [config], domain, user_id, couch_user, True, lang=couch_user.language,
notes=cleaned_data['notes'], once=once
)[0]
body = render_full_report_notification(None, content).content
for recipient in recipient_emails:
send_HTML_email(subject, recipient,
body, email_from=settings.DEFAULT_FROM_EMAIL,
smtp_exception_skip_list=LARGE_FILE_SIZE_ERROR_CODES)
except Exception as er:
notify_exception(
None,
message="Encountered error while generating report or sending email",
details={
'subject': subject,
'recipients': str(recipient_emails),
'error': er,
}
)
if getattr(er, 'smtp_code', None) in LARGE_FILE_SIZE_ERROR_CODES or type(er) == ESError:
# If the email doesn't work because it is too large to fit in the HTML body,
# send it as an excel attachment.
report_state = {
'request': request_data,
'request_params': json_request(request_data['GET']),
'domain': domain,
'context': {},
}
export_all_rows_task(config.report, report_state, recipient_list=recipient_emails)
else:
self.retry(exc=er)
def edit_module_detail_screens(request, domain, app_id, module_unique_id):
"""
Overwrite module case details. Only overwrites components that have been
provided in the request. Components are short, long, filter, parent_select,
fixture_select and sort_elements.
"""
params = json_request(request.POST)
detail_type = params.get('type')
short = params.get('short', None)
long_ = params.get('long', None)
tabs = params.get('tabs', None)
filter = params.get('filter', ())
custom_xml = params.get('custom_xml', None)
parent_select = params.get('parent_select', None)
fixture_select = params.get('fixture_select', None)
sort_elements = params.get('sort_elements', None)
persist_case_context = params.get('persistCaseContext', None)
persistent_case_context_xml = params.get('persistentCaseContextXML', None)
use_case_tiles = params.get('useCaseTiles', None)
persist_tile_on_forms = params.get("persistTileOnForms", None)
persistent_case_tile_from_module = params.get("persistentCaseTileFromModule", None)
pull_down_tile = params.get("enableTilePullDown", None)
sort_nodeset_columns = params.get("sortNodesetColumns", None)
print_template = params.get('printTemplate', None)
case_list_lookup = params.get("case_list_lookup", None)
search_properties = params.get("search_properties")
custom_variables = {
'short': params.get("short_custom_variables", None),
'long': params.get("long_custom_variables", None)
}
app = get_app(domain, app_id)
try:
module = app.get_module_by_unique_id(module_unique_id)
except ModuleNotFoundException:
# temporary fallback
module = app.get_module(module_unique_id)
if detail_type == 'case':
detail = module.case_details
else:
try:
detail = getattr(module, '{0}_details'.format(detail_type))
except AttributeError:
return HttpResponseBadRequest("Unknown detail type '%s'" % detail_type)
lang = request.COOKIES.get('lang', app.langs[0])
if short is not None:
detail.short.columns = list(map(DetailColumn.from_json, short))
if persist_case_context is not None:
detail.short.persist_case_context = persist_case_context
detail.short.persistent_case_context_xml = persistent_case_context_xml
if use_case_tiles is not None:
detail.short.use_case_tiles = use_case_tiles
if persist_tile_on_forms is not None:
detail.short.persist_tile_on_forms = persist_tile_on_forms
if persistent_case_tile_from_module is not None:
detail.short.persistent_case_tile_from_module = persistent_case_tile_from_module
if pull_down_tile is not None:
detail.short.pull_down_tile = pull_down_tile
if case_list_lookup is not None:
_save_case_list_lookup_params(detail.short, case_list_lookup, lang)
if long_ is not None:
detail.long.columns = list(map(DetailColumn.from_json, long_))
if tabs is not None:
detail.long.tabs = list(map(DetailTab.wrap, tabs))
if print_template is not None:
detail.long.print_template = print_template
if filter != ():
# Note that we use the empty tuple as the sentinel because a filter
# value of None represents clearing the filter.
detail.short.filter = filter
if custom_xml is not None:
detail.short.custom_xml = custom_xml
if custom_variables['short'] is not None:
try:
etree.fromstring("<variables>{}</variables>".format(custom_variables['short']))
except etree.XMLSyntaxError as error:
return HttpResponseBadRequest(
"There was an issue with your custom variables: {}".format(error.message)
)
detail.short.custom_variables = custom_variables['short']
if custom_variables['long'] is not None:
try:
etree.fromstring("<variables>{}</variables>".format(custom_variables['long']))
except etree.XMLSyntaxError as error:
return HttpResponseBadRequest(
"There was an issue with your custom variables: {}".format(error.message)
)
detail.long.custom_variables = custom_variables['long']
if sort_nodeset_columns is not None:
detail.long.sort_nodeset_columns = sort_nodeset_columns
if sort_elements is not None:
# Attempt to map new elements to old so we don't lose translations
# Imperfect because the same field may be used multiple times, or user may change field
old_elements_by_field = {e['field']: e for e in detail.short.sort_elements}
detail.short.sort_elements = []
for sort_element in sort_elements:
item = SortElement()
item.field = sort_element['field']
item.type = sort_element['type']
item.direction = sort_element['direction']
item.blanks = sort_element['blanks']
if item.field in old_elements_by_field:
item.display = old_elements_by_field[item.field].display
item.display[lang] = sort_element['display']
if toggles.SORT_CALCULATION_IN_CASE_LIST.enabled(domain):
item.sort_calculation = sort_element['sort_calculation']
else:
item.sort_calculation = ""
detail.short.sort_elements.append(item)
if parent_select is not None:
module.parent_select = ParentSelect.wrap(parent_select)
if module_case_hierarchy_has_circular_reference(module):
return HttpResponseBadRequest(_("The case hierarchy contains a circular reference."))
if fixture_select is not None:
module.fixture_select = FixtureSelect.wrap(fixture_select)
if search_properties is not None:
if (
search_properties.get('properties') is not None
or search_properties.get('default_properties') is not None
):
module.search_config = CaseSearch(
properties=[
CaseSearchProperty.wrap(p)
for p in _update_search_properties(
module,
search_properties.get('properties'), lang
)
],
relevant=(
search_properties.get('relevant')
if search_properties.get('relevant') is not None
else CLAIM_DEFAULT_RELEVANT_CONDITION
),
include_closed=bool(search_properties.get('include_closed')),
search_button_display_condition=search_properties.get('search_button_display_condition', ""),
blacklisted_owner_ids_expression=search_properties.get('blacklisted_owner_ids_expression', ""),
default_properties=[
DefaultCaseSearchProperty.wrap(p)
for p in search_properties.get('default_properties')
]
)
resp = {}
app.save(resp)
return json_response(resp)
def _get_and_send_report(self, language, emails):
from corehq.apps.reports.views import get_scheduled_report_response, render_full_report_notification
with localize(language):
title = (_(DEFAULT_REPORT_NOTIF_SUBJECT) if self.email_subject
== DEFAULT_REPORT_NOTIF_SUBJECT else self.email_subject)
attach_excel = getattr(self, 'attach_excel', False)
try:
content, excel_files = get_scheduled_report_response(
self.owner,
self.domain,
self._id,
attach_excel=attach_excel,
send_only_active=True)
# Will be False if ALL the ReportConfigs in the ReportNotification
# have a start_date in the future.
if content is False:
return
for email in emails:
body = render_full_report_notification(
None, content, email, self).content
send_html_email_async(
title,
email,
body,
email_from=settings.DEFAULT_FROM_EMAIL,
file_attachments=excel_files,
smtp_exception_skip_list=LARGE_FILE_SIZE_ERROR_CODES)
except Exception as er:
notify_exception(
None,
message=
"Encountered error while generating report or sending email",
details={
'subject': title,
'recipients': str(emails),
'error': er,
})
if getattr(er, 'smtp_code',
None) in LARGE_FILE_SIZE_ERROR_CODES or type(
er) == ESError:
# If the email doesn't work because it is too large to fit in the HTML body,
# send it as an excel attachment, by creating a mock request with the right data.
for report_config in self.configs:
mock_request = HttpRequest()
mock_request.couch_user = self.owner
mock_request.user = self.owner.get_django_user()
mock_request.domain = self.domain
mock_request.couch_user.current_domain = self.domain
mock_request.couch_user.language = self.language
mock_request.method = 'GET'
mock_request.bypass_two_factor = True
mock_query_string_parts = [
report_config.query_string, 'filterSet=true'
]
if report_config.is_configurable_report:
mock_query_string_parts.append(
urlencode(report_config.filters, True))
mock_query_string_parts.append(
urlencode(report_config.get_date_range(),
True))
mock_request.GET = QueryDict(
'&'.join(mock_query_string_parts))
date_range = report_config.get_date_range()
start_date = datetime.strptime(date_range['startdate'],
'%Y-%m-%d')
end_date = datetime.strptime(date_range['enddate'],
'%Y-%m-%d')
datespan = DateSpan(start_date, end_date)
request_data = vars(mock_request)
request_data[
'couch_user'] = mock_request.couch_user.userID
request_data['datespan'] = datespan
full_request = {
'request': request_data,
'domain': request_data['domain'],
'context': {},
'request_params': json_request(request_data['GET'])
}
export_all_rows_task(report_config.report,
full_request, emails, title)
def request_dict(self):
params = json_request(self.request.GET)
params['domain'] = self.domain
return params
def post(self, request, *args, **kwargs):
request_json = json_request(request.POST)
self.doc = request_json.get('doc')
self.save_doc()
return self.get(request, success=True, *args, **kwargs)
def edit_module_detail_screens(request, domain, app_id, module_id):
"""
Overwrite module case details. Only overwrites components that have been
provided in the request. Components are short, long, filter, parent_select,
fixture_select and sort_elements.
"""
params = json_request(request.POST)
detail_type = params.get('type')
short = params.get('short', None)
long = params.get('long', None)
tabs = params.get('tabs', None)
filter = params.get('filter', ())
custom_xml = params.get('custom_xml', None)
parent_select = params.get('parent_select', None)
fixture_select = params.get('fixture_select', None)
sort_elements = params.get('sort_elements', None)
persist_case_context = params.get('persistCaseContext', None)
use_case_tiles = params.get('useCaseTiles', None)
persist_tile_on_forms = params.get("persistTileOnForms", None)
pull_down_tile = params.get("enableTilePullDown", None)
case_list_lookup = params.get("case_list_lookup", None)
app = get_app(domain, app_id)
module = app.get_module(module_id)
if detail_type == 'case':
detail = module.case_details
elif detail_type == CAREPLAN_GOAL:
detail = module.goal_details
elif detail_type == CAREPLAN_TASK:
detail = module.task_details
else:
try:
detail = getattr(module, '{0}_details'.format(detail_type))
except AttributeError:
return HttpResponseBadRequest("Unknown detail type '%s'" % detail_type)
if short is not None:
detail.short.columns = map(DetailColumn.wrap, short)
if persist_case_context is not None:
detail.short.persist_case_context = persist_case_context
if use_case_tiles is not None:
detail.short.use_case_tiles = use_case_tiles
if persist_tile_on_forms is not None:
detail.short.persist_tile_on_forms = persist_tile_on_forms
if pull_down_tile is not None:
detail.short.pull_down_tile = pull_down_tile
if case_list_lookup is not None:
_save_case_list_lookup_params(detail.short, case_list_lookup)
if long is not None:
detail.long.columns = map(DetailColumn.wrap, long)
if tabs is not None:
detail.long.tabs = map(DetailTab.wrap, tabs)
if filter != ():
# Note that we use the empty tuple as the sentinel because a filter
# value of None represents clearing the filter.
detail.short.filter = filter
if custom_xml is not None:
detail.short.custom_xml = custom_xml
if sort_elements is not None:
detail.short.sort_elements = []
for sort_element in sort_elements:
item = SortElement()
item.field = sort_element['field']
item.type = sort_element['type']
item.direction = sort_element['direction']
detail.short.sort_elements.append(item)
if parent_select is not None:
module.parent_select = ParentSelect.wrap(parent_select)
if fixture_select is not None:
module.fixture_select = FixtureSelect.wrap(fixture_select)
resp = {}
app.save(resp)
return json_response(resp)
def edit_module_detail_screens(request, domain, app_id, module_id):
"""
Overwrite module case details. Only overwrites components that have been
provided in the request. Components are short, long, filter, parent_select,
fixture_select and sort_elements.
"""
params = json_request(request.POST)
detail_type = params.get('type')
short = params.get('short', None)
long = params.get('long', None)
tabs = params.get('tabs', None)
filter = params.get('filter', ())
custom_xml = params.get('custom_xml', None)
parent_select = params.get('parent_select', None)
fixture_select = params.get('fixture_select', None)
sort_elements = params.get('sort_elements', None)
persist_case_context = params.get('persistCaseContext', None)
persistent_case_context_xml = params.get('persistentCaseContextXML', None)
use_case_tiles = params.get('useCaseTiles', None)
persist_tile_on_forms = params.get("persistTileOnForms", None)
pull_down_tile = params.get("enableTilePullDown", None)
case_list_lookup = params.get("case_list_lookup", None)
search_properties = params.get("search_properties")
app = get_app(domain, app_id)
module = app.get_module(module_id)
if detail_type == 'case':
detail = module.case_details
elif detail_type == CAREPLAN_GOAL:
detail = module.goal_details
elif detail_type == CAREPLAN_TASK:
detail = module.task_details
else:
try:
detail = getattr(module, '{0}_details'.format(detail_type))
except AttributeError:
return HttpResponseBadRequest("Unknown detail type '%s'" %
detail_type)
lang = request.COOKIES.get('lang', app.langs[0])
if short is not None:
detail.short.columns = map(DetailColumn.from_json, short)
if persist_case_context is not None:
detail.short.persist_case_context = persist_case_context
detail.short.persistent_case_context_xml = persistent_case_context_xml
if use_case_tiles is not None:
detail.short.use_case_tiles = use_case_tiles
if persist_tile_on_forms is not None:
detail.short.persist_tile_on_forms = persist_tile_on_forms
if pull_down_tile is not None:
detail.short.pull_down_tile = pull_down_tile
if case_list_lookup is not None:
_save_case_list_lookup_params(detail.short, case_list_lookup, lang)
if long is not None:
detail.long.columns = map(DetailColumn.from_json, long)
if tabs is not None:
detail.long.tabs = map(DetailTab.wrap, tabs)
if filter != ():
# Note that we use the empty tuple as the sentinel because a filter
# value of None represents clearing the filter.
detail.short.filter = filter
if custom_xml is not None:
detail.short.custom_xml = custom_xml
if sort_elements is not None:
detail.short.sort_elements = []
for sort_element in sort_elements:
item = SortElement()
item.field = sort_element['field']
item.type = sort_element['type']
item.direction = sort_element['direction']
item.display[lang] = sort_element['display']
detail.short.sort_elements.append(item)
if parent_select is not None:
module.parent_select = ParentSelect.wrap(parent_select)
if fixture_select is not None:
module.fixture_select = FixtureSelect.wrap(fixture_select)
if search_properties is not None:
if search_properties.get('properties') is not None:
module.search_config = CaseSearch(
properties=[
CaseSearchProperty.wrap(p)
for p in _update_search_properties(
module, search_properties.get('properties'), lang)
],
relevant=(search_properties.get('relevant')
if search_properties.get('relevant') is not None else
CLAIM_DEFAULT_RELEVANT_CONDITION))
resp = {}
app.save(resp)
return json_response(resp)
def get_translations(request):
params = json_request(request.GET)
lang = params.get('lang', 'en')
key = params.get('key', None)
one = params.get('one', False)
return json_response(Translation.get_translations(lang, key, one))
open_cases = CommCareCase.view('hqcase/open_cases', startkey=[domain], endkey=[domain, {}], reduce=False, include_docs=True).all()
xform_ids = [case.xform_ids[0] for case in open_cases]
case_count = defaultdict(int)
for xform_id in xform_ids:
xform = XFormInstance.get(xform_id)
meta = xform.form['meta']
case_count[(meta['userID'], meta['username'], meta['deviceID'])] += 1
for sub in subs:
sub['cases'] = case_count[(sub['userID'], sub['username'], sub['deviceID'])]
return json_response({
"results": subs,
"total": len(subs),
})
return query(**json_request(request.GET))
@require_can_cleanup
@require_POST
def close_cases(request, domain):
data = json.loads(request.POST['data'])
keys = data['submissions']
def actually_close_cases(cases):
for case in cases:
for referral in case.referrals:
case.force_close_referral(get_submit_url(domain), referral)
case.force_close(get_submit_url(domain))
xforms = _get_submissions(domain, keys)
cases = _get_cases(xforms)
actually_close_cases(cases)
return HttpResponseRedirect(reverse('corehq.apps.cleanup.views.cases', args=[domain]))
def submissions_json(request, domain):
def query(limit=100, userID=None, group=False, username__exclude=["demo_user", "admin"], **kwargs):
if group:
if userID is None:
key = [domain]
else:
key = [domain, userID]
subs = [dict(
userID = r['key'][1],
username = r['key'][2],
deviceID = r['key'][3],
submissions = r['value'],
) for r in get_db().view('cleanup/submissions',
startkey = key,
endkey = key + [{}],
group = True,
)]
total = len(subs)
else:
if userID is None:
key = make_form_couch_key(domain)
subs = XFormInstance.view('reports_forms/all_forms',
startkey=key+[{}],
endkey=key,
reduce=False,
include_docs=True,
descending=True,
limit=limit
)
total = get_db().view('reports_forms/all_forms',
startkey=key,
endkey=key+[{}],
group_level=1
).one()
total = total['value'] if total else 0
else:
key = make_form_couch_key(domain, user_id=userID)
subs = XFormInstance.view('reports_forms/all_forms',
startkey=key+[{}],
endkey=key,
reduce=False,
include_docs=True,
descending=True,
limit=limit
)
total = get_db().view('reports_forms/all_forms',
startkey=key,
endkey=key+[{}],
group_level=2
).one()
total = total['value'] if total else 0
_subs = []
for s in subs:
try:
_subs.append(dict(
username = s['form']['meta']['username'],
userID = s['form']['meta']['userID'],
received_on = unicode(s['received_on']),
deviceID = s['form']['meta']['deviceID'],
))
except:
continue
subs = _subs
if username__exclude:
username__exclude = set(username__exclude)
subs = filter(lambda sub: sub['username'] not in username__exclude, subs)
return json_response({
"results": subs,
"total": total,
})
return query(**json_request(request.GET))
def send_email_report(self, recipient_emails, domain, report_slug, report_type,
request_data, once, cleaned_data):
"""
Function invokes send_HTML_email to email the html text report.
If the report is too large to fit into email then a download link is
sent via email to download report
:Parameter recipient_list:
list of recipient to whom email is to be sent
:Parameter domain:
domain name
:Parameter report_slug:
report slug
:Parameter report_type:
type of the report
:Parameter request_data:
Dict containing request data
:Parameter once
boolean argument specifying whether the report is once off report
or scheduled report
:Parameter cleaned_data:
Dict containing cleaned data from the submitted form
"""
from corehq.apps.reports.views import _render_report_configs, render_full_report_notification
user_id = request_data['couch_user']
couch_user = CouchUser.get_by_user_id(user_id)
mock_request = HttpRequest()
mock_request.method = 'GET'
mock_request.GET = request_data['GET']
config = ReportConfig()
# see ReportConfig.query_string()
object.__setattr__(config, '_id', 'dummy')
config.name = _("Emailed report")
config.report_type = report_type
config.report_slug = report_slug
config.owner_id = user_id
config.domain = domain
config.start_date = request_data['datespan'].startdate.date()
if request_data['datespan'].enddate:
config.date_range = 'range'
config.end_date = request_data['datespan'].enddate.date()
else:
config.date_range = 'since'
GET = dict(six.iterlists(request_data['GET']))
exclude = [
'startdate', 'enddate', 'subject', 'send_to_owner', 'notes',
'recipient_emails'
]
filters = {}
for field in GET:
if field not in exclude:
filters[field] = GET.get(field)
config.filters = filters
subject = cleaned_data['subject'] or _("Email report from CommCare HQ")
content = _render_report_configs(mock_request, [config],
domain,
user_id,
couch_user,
True,
lang=couch_user.language,
notes=cleaned_data['notes'],
once=once)[0]
body = render_full_report_notification(None, content).content
try:
for recipient in recipient_emails:
send_HTML_email(
subject,
recipient,
body,
email_from=settings.DEFAULT_FROM_EMAIL,
smtp_exception_skip_list=LARGE_FILE_SIZE_ERROR_CODES)
except Exception as er:
if getattr(er, 'smtp_code', None) in LARGE_FILE_SIZE_ERROR_CODES:
# If the smtp server rejects the email because of its large size.
# Then sends the report download link in the email.
report_state = {
'request': request_data,
'request_params': json_request(request_data['GET']),
'domain': domain,
'context': {},
}
export_all_rows_task(config.report,
report_state,
recipient_list=recipient_emails)
else:
self.retry(exc=er)
def post(self, request, *args, **kwargs):
request_json = json_request(request.POST)
self.doc = request_json.get('doc')
self.save_doc()
return self.get(request, success=True, *args, **kwargs)
def _init_data_source(self, data_source, request, domain):
config = json_request(request.GET)
config['domain'] = domain.name
return data_source(config)
def request_dict(self):
params = json_request(self.request.GET)
params['domain'] = self.domain
return params
def _init_data_source(self, data_source, request, domain):
config = json_request(request.GET)
config['domain'] = domain.name
return data_source(config)
def request_params(self):
return json_request({})
def request_dict(self):
request_dict = json_request(self.request.GET)
request_dict['domain'] = self.domain
return request_dict
