def get_timezone(domain, couch_user):
if not domain:
return pytz.utc
else:
try:
return get_timezone_for_user(couch_user, domain)
except AttributeError:
return get_timezone_for_user(None, domain)
def get_report_timezone(request, domain):
if not domain:
return pytz.utc
else:
try:
return get_timezone_for_user(request.couch_user, domain)
except AttributeError:
return get_timezone_for_user(None, domain)
def get_report_timezone(request, domain):
if not domain:
return pytz.utc
else:
try:
return get_timezone_for_user(request.couch_user, domain)
except AttributeError:
return get_timezone_for_user(None, domain)
def timezone(self):
if not self.domain:
return pytz.utc
else:
try:
return get_timezone_for_user(self.request.couch_user, self.domain)
except AttributeError:
return get_timezone_for_user(None, self.domain)
def timezone(self):
if not self.domain:
return pytz.utc
else:
try:
return get_timezone_for_user(self.request.couch_user, self.domain)
except AttributeError:
return get_timezone_for_user(None, self.domain)
def test_user_with_domain_membership(self, domain_membership_mock):
couch_user = WebUser()
domain_membership = DomainMembership()
domain_membership_timezone = pytz.timezone('America/New_York')
domain_membership.timezone = 'America/New_York'
domain_membership_mock.return_value = domain_membership
# if not override_global_tz
self.assertEqual(get_timezone_for_user(couch_user, "test"),
DOMAIN_TIMEZONE)
# if override_global_tz
domain_membership.override_global_tz = True
self.assertEqual(get_timezone_for_user(couch_user, "test"),
domain_membership_timezone)
def paginate_releases(request, domain, app_id):
limit = request.GET.get('limit')
try:
limit = int(limit)
except (TypeError, ValueError):
limit = 10
start_build_param = request.GET.get('start_build')
if start_build_param and json.loads(start_build_param):
start_build = json.loads(start_build_param)
assert isinstance(start_build, int)
else:
start_build = {}
timezone = get_timezone_for_user(request.couch_user, domain)
saved_apps = Application.get_db().view(
'app_manager/saved_app',
startkey=[domain, app_id, start_build],
endkey=[domain, app_id],
descending=True,
limit=limit,
wrapper=lambda x: SavedAppBuild.wrap(x['value']).to_saved_build_json(
timezone),
).all()
j2me_enabled_configs = CommCareBuildConfig.j2me_enabled_config_labels()
for app in saved_apps:
app['include_media'] = app['doc_type'] != 'RemoteApp'
app['j2me_enabled'] = app['menu_item_label'] in j2me_enabled_configs
if toggles.APPLICATION_ERROR_REPORT.enabled(request.couch_user.username):
versions = [app['version'] for app in saved_apps]
num_errors_dict = _get_error_counts(domain, app_id, versions)
for app in saved_apps:
app['num_errors'] = num_errors_dict.get(app['version'], 0)
return json_response(saved_apps)
def get_apps_base_context(request, domain, app):
lang, langs = get_langs(request, app)
if getattr(request, "couch_user", None):
timezone = get_timezone_for_user(request.couch_user, domain)
else:
timezone = None
context = {"lang": lang, "langs": langs, "domain": domain, "app": app, "timezone": timezone}
if app and not app.is_remote_app():
app.assert_app_v2()
context.update(
{
"show_care_plan": (
not app.has_careplan_module and toggles.APP_BUILDER_CAREPLAN.enabled(request.user.username)
),
"show_advanced": (
toggles.APP_BUILDER_ADVANCED.enabled(domain) or getattr(app, "commtrack_enabled", False)
),
"show_report_modules": toggles.MOBILE_UCR.enabled(domain),
"show_shadow_modules": toggles.APP_BUILDER_SHADOW_MODULES.enabled(domain),
}
)
return context
def save_copy(request, domain, app_id):
"""
Saves a copy of the app to a new doc.
See ApplicationBase.save_copy
"""
track_built_app_on_hubspot.delay(request.couch_user)
comment = request.POST.get('comment')
app = get_app(domain, app_id)
try:
errors = app.validate_app()
except ModuleIdMissingException:
# For apps (mainly Exchange apps) that lost unique_id attributes on Module
app.ensure_module_unique_ids(should_save=True)
errors = app.validate_app()
if not errors:
try:
user_id = request.couch_user.get_id
timer = datadog_bucket_timer('commcare.app_build.new_release',
tags=[],
timing_buckets=(1, 10, 30, 60, 120,
240))
with timer:
copy = make_app_build(app, comment, user_id)
CouchUser.get(user_id).set_has_built_app()
except BuildConflictException:
return JsonResponse(
{
'error':
_("There is already a version build in progress. Please wait."
)
},
status=400)
finally:
# To make a RemoteApp always available for building
if app.is_remote_app():
app.save(increment_version=True)
_track_build_for_app_preview(domain, request.couch_user, app_id,
'User created a build')
else:
copy = None
copy = copy and SavedAppBuild.wrap(copy.to_json()).releases_list_json(
get_timezone_for_user(request.couch_user, domain))
lang, langs = get_langs(request, app)
return json_response({
"saved_app":
copy,
"error_html":
render_to_string(
"app_manager/partials/build_errors.html", {
'app': get_app(domain, app_id),
'build_errors': errors,
'domain': domain,
'langs': langs,
}),
})
def export_table(self):
"""
Returns a multi-dimensional list formatted as export_from_tables would expect. It includes all context
(study data and subjects) required to render an ODM document.
"""
tz = get_timezone_for_user(None, self.domain)
now = datetime.now(tz)
file_oid = now.strftime('CommCare_%Y%m%d%H%M%S%z')
utc_offset = now.strftime('%z')
with_colon = ':'.join((utc_offset[:-2], utc_offset[-2:])) # Change UTC offset from "+0200" to "+02:00"
study_details = {
'file_oid': file_oid,
'file_description': 'Data imported from CommCare',
'creation_datetime': now.strftime('%Y-%m-%dT%H:%M:%S') + with_colon,
'study_name': get_study_constant(self.domain, 'study_name'),
'study_description': get_study_constant(self.domain, 'study_description'),
'protocol_name': get_study_constant(self.domain, 'protocol_name'),
'study_oid': get_study_constant(self.domain, 'study_oid'),
'audit_logs': AUDIT_LOGS,
# The template accepts XML strings in params "study_xml" and
# "admin_data_xml" which come from the study metadata.
'study_xml': get_study_constant(self.domain, 'study_xml'),
'admin_data_xml': get_study_constant(self.domain, 'admin_data_xml'),
'domain': self.domain,
}
return [
[
'study', # The first "sheet" is the study details. It has only one row.
[list(study_details.keys()), list(study_details.values())]
],
[
'subjects',
[self.subject_headers()] + list(self.export_rows)
]
]
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 paginate_releases(request, domain, app_id):
limit = request.GET.get('limit')
try:
limit = int(limit)
except (TypeError, ValueError):
limit = 10
start_build_param = request.GET.get('start_build')
if start_build_param and json.loads(start_build_param):
start_build = json.loads(start_build_param)
assert isinstance(start_build, int)
else:
start_build = {}
timezone = get_timezone_for_user(request.couch_user, domain)
saved_apps = Application.get_db().view('app_manager/saved_app',
startkey=[domain, app_id, start_build],
endkey=[domain, app_id],
descending=True,
limit=limit,
wrapper=lambda x: SavedAppBuild.wrap(x['value']).to_saved_build_json(timezone),
).all()
for app in saved_apps:
app['include_media'] = app['doc_type'] != 'RemoteApp'
if toggles.APPLICATION_ERROR_REPORT.enabled(request.couch_user.username):
versions = [app['version'] for app in saved_apps]
num_errors_dict = _get_error_counts(domain, app_id, versions)
for app in saved_apps:
app['num_errors'] = num_errors_dict.get(app['version'], 0)
return json_response(saved_apps)
def paginate_releases(request, domain, app_id):
limit = request.GET.get("limit")
try:
limit = int(limit)
except (TypeError, ValueError):
limit = 10
start_build_param = request.GET.get("start_build")
if start_build_param and json.loads(start_build_param):
start_build = json.loads(start_build_param)
assert isinstance(start_build, int)
else:
start_build = {}
timezone = get_timezone_for_user(request.couch_user, domain)
saved_apps = (
Application.get_db()
.view(
"app_manager/saved_app",
startkey=[domain, app_id, start_build],
endkey=[domain, app_id],
descending=True,
limit=limit,
wrapper=lambda x: SavedAppBuild.wrap(x["value"]).to_saved_build_json(timezone),
)
.all()
)
for app in saved_apps:
app["include_media"] = app["doc_type"] != "RemoteApp"
return json_response(saved_apps)
def registry_audit_logs(request, domain, registry_slug):
helper = DataRegistryAuditViewHelper(domain, registry_slug)
if not RegistryPermissionCheck(
domain, request.couch_user).can_manage_registry(registry_slug):
return JsonResponse({"error": "Permission denied"}, status=403)
limit = int(request.GET.get('limit', 10))
page = int(request.GET.get('page', 1))
skip = limit * (page - 1)
try:
start_date = _get_date_param(request, 'startDate')
end_date = _get_date_param(request, 'endDate')
except ValueError:
return JsonResponse({"error": "Invalid date parameter"})
domain_param = request.GET.get('domain') or None
action = request.GET.get('action') or None
helper.filter(domain_param, start_date, end_date, action)
timezone = get_timezone_for_user(request.couch_user, domain)
logs = helper.get_logs(skip, limit)
for log in logs:
log['date'] = ServerTime(
log['date']).user_time(timezone).done().isoformat()
return JsonResponse({"total": helper.get_total(), "logs": logs})
def save_copy(request, domain, app_id):
"""
Saves a copy of the app to a new doc.
See VersionedDoc.save_copy
"""
track_built_app_on_hubspot.delay(request.couch_user)
comment = request.POST.get('comment')
app = get_app(domain, app_id)
try:
errors = app.validate_app()
except ModuleIdMissingException:
# For apps (mainly Exchange apps) that lost unique_id attributes on Module
app.ensure_module_unique_ids(should_save=True)
errors = app.validate_app()
if not errors:
try:
copy = app.make_build(
comment=comment,
user_id=request.couch_user.get_id,
previous_version=app.get_latest_app(released_only=False))
copy.save(increment_version=False)
finally:
# To make a RemoteApp always available for building
if app.is_remote_app():
app.save(increment_version=True)
_track_build_for_app_preview(domain, request.couch_user, app_id,
'User created a build')
else:
copy = None
copy = copy and SavedAppBuild.wrap(copy.to_json()).to_saved_build_json(
get_timezone_for_user(request.couch_user, domain))
lang, langs = get_langs(request, app)
if copy:
# Set if build is supported for Java Phones
j2me_enabled_configs = CommCareBuildConfig.j2me_enabled_config_labels()
copy['j2me_enabled'] = copy['menu_item_label'] in j2me_enabled_configs
template = get_app_manager_template(
request.user,
"app_manager/v1/partials/build_errors.html",
"app_manager/v2/partials/build_errors.html",
)
return json_response({
"saved_app":
copy,
"error_html":
render_to_string(
template, {
'request': request,
'app': get_app(domain, app_id),
'build_errors': errors,
'domain': domain,
'langs': langs,
'lang': lang
}),
})
def export_table(self):
"""
Returns a multi-dimensional list formatted as export_from_tables would expect. It includes all context
(study data and subjects) required to render an ODM document.
"""
tz = get_timezone_for_user(None, self.domain)
now = datetime.now(tz)
file_oid = now.strftime('CommCare_%Y%m%d%H%M%S%z')
utc_offset = now.strftime('%z')
with_colon = ':'.join((utc_offset[:-2], utc_offset[-2:])) # Change UTC offset from "+0200" to "+02:00"
study_details = {
'file_oid': file_oid,
'file_description': 'Data imported from CommCare',
'creation_datetime': now.strftime('%Y-%m-%dT%H:%M:%S') + with_colon,
'study_name': get_study_constant(self.domain, 'study_name'),
'study_description': get_study_constant(self.domain, 'study_description'),
'protocol_name': get_study_constant(self.domain, 'protocol_name'),
'study_oid': get_study_constant(self.domain, 'study_oid'),
'audit_logs': AUDIT_LOGS,
# The template accepts XML strings in params "study_xml" and
# "admin_data_xml" which come from the study metadata.
'study_xml': get_study_constant(self.domain, 'study_xml'),
'admin_data_xml': get_study_constant(self.domain, 'admin_data_xml'),
'domain': self.domain,
}
return [
[
'study', # The first "sheet" is the study details. It has only one row.
[list(study_details.keys()), list(study_details.values())]
],
[
'subjects',
[self.subject_headers()] + list(self.export_rows)
]
]
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 get_apps_base_context(request, domain, app):
lang, langs = get_langs(request, app)
if getattr(request, 'couch_user', None):
timezone = get_timezone_for_user(request.couch_user, domain)
else:
timezone = None
context = {
'lang': lang,
'langs': langs,
'domain': domain,
'app': app,
'timezone': timezone,
}
if app and not app.is_remote_app():
app.assert_app_v2()
context.update({
'show_care_plan':
(not app.has_careplan_module
and toggles.APP_BUILDER_CAREPLAN.enabled(request.user.username)),
'show_advanced': (toggles.APP_BUILDER_ADVANCED.enabled(domain)
or getattr(app, 'commtrack_enabled', False)),
'show_report_modules':
toggles.MOBILE_UCR.enabled(domain),
'show_shadow_modules':
toggles.APP_BUILDER_SHADOW_MODULES.enabled(domain),
})
return context
def get_apps_base_context(request, domain, app):
lang, langs = get_langs(request, app)
if getattr(request, 'couch_user', None):
timezone = get_timezone_for_user(request.couch_user, domain)
else:
timezone = None
context = {
'lang': lang,
'langs': langs,
'domain': domain,
'app': app,
'app_subset': {
'commcare_minor_release': app.commcare_minor_release,
'doc_type': app.get_doc_type(),
'form_counts_by_module': [len(m.forms) for m in app.modules] if not app.is_remote_app() else [],
'version': app.version,
} if app else {},
'timezone': timezone,
}
if app and not app.is_remote_app():
app.assert_app_v2()
show_advanced = (
toggles.APP_BUILDER_ADVANCED.enabled(domain)
or getattr(app, 'commtrack_enabled', False)
)
disable_report_modules = (
is_master_linked_domain(domain)
and not toggles.MOBILE_UCR_LINKED_DOMAIN.enabled(domain)
)
# ideally this should be loaded on demand
practice_users = []
if app.enable_practice_users:
try:
practice_users = get_practice_mode_mobile_workers(request.domain)
except ESError:
notify_exception(request, 'Error getting practice mode mobile workers')
latest_version_for_build_profiles = {}
if toggles.RELEASE_BUILDS_PER_PROFILE.enabled(domain):
latest_version_for_build_profiles = get_latest_enabled_versions_per_profile(app.get_id)
context.update({
'show_advanced': show_advanced,
'show_report_modules': toggles.MOBILE_UCR.enabled(domain),
'disable_report_modules': disable_report_modules,
'show_shadow_modules': toggles.APP_BUILDER_SHADOW_MODULES.enabled(domain),
'show_shadow_forms': show_advanced,
'show_training_modules': toggles.TRAINING_MODULE.enabled(domain) and app.enable_training_modules,
'practice_users': [{"id": u['_id'], "text": u["username"]} for u in practice_users],
'latest_version_for_build_profiles': latest_version_for_build_profiles,
})
return context
def save_copy(request, domain, app_id):
"""
Saves a copy of the app to a new doc.
See VersionedDoc.save_copy
"""
track_built_app_on_hubspot_v2.delay(request.couch_user)
comment = request.POST.get('comment')
app = get_app(domain, app_id)
try:
errors = app.validate_app()
except ModuleIdMissingException:
# For apps (mainly Exchange apps) that lost unique_id attributes on Module
app.ensure_module_unique_ids(should_save=True)
errors = app.validate_app()
if not errors:
try:
user_id = request.couch_user.get_id
timer = datadog_bucket_timer('commcare.app_build.new_release', tags=[],
timing_buckets=(1, 10, 30, 60, 120, 240))
with timer:
copy = app.make_build(
comment=comment,
user_id=user_id,
)
copy.save(increment_version=False)
CouchUser.get(user_id).set_has_built_app()
finally:
# To make a RemoteApp always available for building
if app.is_remote_app():
app.save(increment_version=True)
_track_build_for_app_preview(domain, request.couch_user, app_id, 'User created a build')
else:
copy = None
copy = copy and SavedAppBuild.wrap(copy.to_json()).releases_list_json(
get_timezone_for_user(request.couch_user, domain)
)
lang, langs = get_langs(request, app)
if copy:
# Set if build is supported for Java Phones
j2me_enabled_configs = CommCareBuildConfig.j2me_enabled_config_labels()
copy['j2me_enabled'] = copy['menu_item_label'] in j2me_enabled_configs
return json_response({
"saved_app": copy,
"error_html": render_to_string("app_manager/partials/build_errors.html", {
'request': request,
'app': get_app(domain, app_id),
'build_errors': errors,
'domain': domain,
'langs': langs,
'lang': lang
}),
})
def get_context_data(self, **kwargs):
context = super(DataFileDownloadList, self).get_context_data(**kwargs)
context.update({
'timezone': get_timezone_for_user(self.request.couch_user, self.domain),
'data_files': DataFile.get_all(self.domain),
'is_admin': self.request.couch_user.is_domain_admin(self.domain),
'url_base': get_url_base(),
})
return context
def paginate_releases(request, domain, app_id):
limit = request.GET.get('limit')
only_show_released = json.loads(
request.GET.get('only_show_released', 'false'))
build_comment = request.GET.get('build_comment')
page = int(request.GET.get('page', 1))
page = max(page, 1)
try:
limit = int(limit)
except (TypeError, ValueError):
limit = 10
timezone = get_timezone_for_user(request.couch_user, domain)
app_es = (AppES().start((page - 1) * limit).size(limit).sort(
'version', desc=True).domain(domain).is_build().app_id(app_id))
if only_show_released:
app_es = app_es.is_released()
if build_comment:
app_es = app_es.build_comment(build_comment)
results = app_es.exclude_source().run()
app_ids = results.doc_ids
apps = get_docs(Application.get_db(), app_ids)
for app in apps:
app.pop('translations')
saved_apps = [
SavedAppBuild.wrap(
app, scrap_old_conventions=False).to_saved_build_json(timezone)
for app in apps
]
j2me_enabled_configs = CommCareBuildConfig.j2me_enabled_config_labels()
for app in saved_apps:
app['include_media'] = app['doc_type'] != 'RemoteApp'
app['j2me_enabled'] = app['menu_item_label'] in j2me_enabled_configs
app['target_commcare_flavor'] = (
SavedAppBuild.get(app['_id']).target_commcare_flavor
if toggles.TARGET_COMMCARE_FLAVOR.enabled(domain) else 'none')
if toggles.APPLICATION_ERROR_REPORT.enabled(request.couch_user.username):
versions = [app['version'] for app in saved_apps]
num_errors_dict = _get_error_counts(domain, app_id, versions)
for app in saved_apps:
app['num_errors'] = num_errors_dict.get(app['version'], 0)
total_apps = results.total
num_pages = int(ceil(total_apps / limit))
return json_response({
'apps': saved_apps,
'pagination': {
'total': total_apps,
'num_pages': num_pages,
'current_page': page,
}
})
def get_apps_base_context(request, domain, app):
lang, langs = get_langs(request, app)
if getattr(request, 'couch_user', None):
timezone = get_timezone_for_user(request.couch_user, domain)
else:
timezone = None
context = {
'lang': lang,
'langs': langs,
'domain': domain,
'app': app,
'app_subset': {
'commcare_minor_release':
app.commcare_minor_release,
'doc_type':
app.get_doc_type(),
'form_counts_by_module':
[len(m.forms)
for m in app.modules] if not app.is_remote_app() else [],
'version':
app.version,
} if app else {},
'timezone': timezone,
}
if app and not app.is_remote_app():
app.assert_app_v2()
show_advanced = (toggles.APP_BUILDER_ADVANCED.enabled(domain)
or getattr(app, 'commtrack_enabled', False))
context.update({
'show_care_plan':
(not app.has_careplan_module
and toggles.APP_BUILDER_CAREPLAN.enabled(request.user.username)),
'show_advanced':
show_advanced,
'show_report_modules':
toggles.MOBILE_UCR.enabled(domain),
'show_shadow_modules':
toggles.APP_BUILDER_SHADOW_MODULES.enabled(domain),
'show_shadow_forms':
show_advanced,
})
if toggles.APP_MANAGER_V2.enabled(request.user.username):
rollout = toggles.APP_MANAGER_V2.enabled_for_new_users_after
if not toggles.was_user_created_after(request.user.username, rollout):
context.update({'allow_v2_opt_out': True})
return context
def save_copy(request, domain, app_id):
"""
Saves a copy of the app to a new doc.
"""
track_built_app_on_hubspot.delay(request.couch_user.get_id)
comment = request.POST.get('comment')
app = get_app(domain, app_id)
try:
user_id = request.couch_user.get_id
with report_build_time(domain, app._id, 'new_release'):
copy = make_app_build(app, comment, user_id)
CouchUser.get(user_id).set_has_built_app()
except AppValidationError as e:
lang, langs = get_langs(request, app)
return JsonResponse({
"saved_app":
None,
"error_html":
render_to_string(
"app_manager/partials/build_errors.html", {
'app': get_app(domain, app_id),
'build_errors': e.errors,
'domain': domain,
'langs': langs,
'toggles': toggles_enabled_for_request(request),
}),
})
except BuildConflictException:
return JsonResponse(
{
'error':
_("There is already a version build in progress. Please wait.")
},
status=400)
except XFormValidationFailed:
return JsonResponse({'error': _("Unable to validate forms.")},
status=400)
finally:
# To make a RemoteApp always available for building
if app.is_remote_app():
app.save(increment_version=True)
_track_build_for_app_preview(domain, request.couch_user, app_id,
'User created a build')
copy_json = copy and SavedAppBuild.wrap(copy.to_json()).releases_list_json(
get_timezone_for_user(request.couch_user, domain))
return JsonResponse({
"saved_app": copy_json,
"error_html": "",
})
def options(self):
timezone = get_timezone_for_user(self.request.couch_user, self.domain)
records = UserUploadRecord.objects.filter(domain=self.domain).order_by('-date_created')
return [
(
str(record.id),
_("Upload by {username} at {time}").format(
username=cached_user_id_to_user_display(record.user_id),
time=ServerTime(record.date_created).user_time(timezone).ui_string(USER_DATETIME_FORMAT)
)
)
for record in records
]
def paginate_releases(request, domain, app_id):
limit = request.GET.get('limit')
only_show_released = json.loads(
request.GET.get('only_show_released', 'false'))
try:
limit = int(limit)
except (TypeError, ValueError):
limit = 10
start_build_param = request.GET.get('start_build')
if start_build_param and json.loads(start_build_param):
start_build = json.loads(start_build_param)
assert isinstance(start_build, int)
else:
start_build = {}
timezone = get_timezone_for_user(request.couch_user, domain)
saved_apps = []
batch = [None]
while len(saved_apps) < limit and len(batch):
batch = Application.get_db().view(
'app_manager/saved_app',
startkey=[domain, app_id, start_build],
endkey=[domain, app_id],
descending=True,
limit=limit,
wrapper=lambda x: SavedAppBuild.wrap(x['value']).
to_saved_build_json(timezone),
).all()
if len(batch):
start_build = batch[-1]['version'] - 1
saved_apps = saved_apps + [
app
for app in batch if not only_show_released or app['is_released']
]
saved_apps = saved_apps[:limit]
j2me_enabled_configs = CommCareBuildConfig.j2me_enabled_config_labels()
for app in saved_apps:
app['include_media'] = app['doc_type'] != 'RemoteApp'
app['j2me_enabled'] = app['menu_item_label'] in j2me_enabled_configs
app['target_commcare_flavor'] = (
SavedAppBuild.get(app['_id']).target_commcare_flavor
if toggles.TARGET_COMMCARE_FLAVOR.enabled(domain) else 'none')
if toggles.APPLICATION_ERROR_REPORT.enabled(request.couch_user.username):
versions = [app['version'] for app in saved_apps]
num_errors_dict = _get_error_counts(domain, app_id, versions)
for app in saved_apps:
app['num_errors'] = num_errors_dict.get(app['version'], 0)
return json_response(saved_apps)
def get_apps_base_context(request, domain, app):
lang, langs = get_langs(request, app)
if getattr(request, 'couch_user', None):
timezone = get_timezone_for_user(request.couch_user, domain)
else:
timezone = None
context = {
'lang': lang,
'langs': langs,
'domain': domain,
'app': app,
'app_subset': {
'commcare_minor_release':
app.commcare_minor_release,
'doc_type':
app.get_doc_type(),
'form_counts_by_module':
[len(m.forms)
for m in app.modules] if not app.is_remote_app() else [],
'version':
app.version,
} if app else {},
'timezone': timezone,
}
if app and not app.is_remote_app():
app.assert_app_v2()
show_advanced = (toggles.APP_BUILDER_ADVANCED.enabled(domain)
or getattr(app, 'commtrack_enabled', False))
context.update({
'show_advanced':
show_advanced,
'show_report_modules':
toggles.MOBILE_UCR.enabled(domain),
'show_shadow_modules':
toggles.APP_BUILDER_SHADOW_MODULES.enabled(domain),
'show_shadow_forms':
show_advanced,
'show_training_modules':
toggles.TRAINING_MODULE.enabled(domain)
and app.enable_training_modules,
'practice_users': [{
"id": u['_id'],
"text": u["username"]
} for u in get_practice_mode_mobile_workers(domain)],
})
return context
def save_copy(request, domain, app_id):
"""
Saves a copy of the app to a new doc.
See VersionedDoc.save_copy
"""
track_built_app_on_hubspot.delay(request.couch_user)
comment = request.POST.get("comment")
app = get_app(domain, app_id)
try:
errors = app.validate_app()
except ModuleIdMissingException:
# For apps (mainly Exchange apps) that lost unique_id attributes on Module
app.ensure_module_unique_ids(should_save=True)
errors = app.validate_app()
if not errors:
try:
copy = app.make_build(
comment=comment,
user_id=request.couch_user.get_id,
previous_version=app.get_latest_app(released_only=False),
)
copy.save(increment_version=False)
finally:
# To make a RemoteApp always available for building
if app.is_remote_app():
app.save(increment_version=True)
else:
copy = None
copy = copy and SavedAppBuild.wrap(copy.to_json()).to_saved_build_json(
get_timezone_for_user(request.couch_user, domain)
)
lang, langs = get_langs(request, app)
return json_response(
{
"saved_app": copy,
"error_html": render_to_string(
"app_manager/partials/build_errors.html",
{
"app": get_app(domain, app_id),
"build_errors": errors,
"domain": domain,
"langs": langs,
"lang": lang,
},
),
}
)
def get_interactive_participants(domain):
cases = get_cases_in_domain(domain, 'participant')
result = []
timezone = get_timezone_for_user(None, domain) # Use project timezone only
current_date = datetime.now(tz=timezone).date()
for case in cases:
study_arm = case.get_case_property("study_arm")
if isinstance(study_arm, six.string_types) and study_arm.upper() == "A" and not case.closed:
start_date = get_date(case, "start_date")
if start_date is None:
continue
end_date = start_date + timedelta(days=55)
if start_date <= current_date <= end_date:
result.append(case)
return result
def get_interactive_participants(domain):
cases = CommCareCase.view("hqcase/types_by_domain", key=[domain, "participant"], include_docs=True, reduce=False).all()
result = []
timezone = get_timezone_for_user(None, domain) # Use project timezone only
current_date = datetime.now(tz=timezone).date()
for case in cases:
study_arm = case.get_case_property("study_arm")
if isinstance(study_arm, basestring) and study_arm.upper() == "A" and not case.closed:
start_date = get_date(case, "start_date")
if start_date is None:
continue
end_date = start_date + timedelta(days=55)
if current_date >= start_date and current_date <= end_date:
result.append(case)
return result
def get_interactive_participants(domain):
cases = get_cases_in_domain(domain, 'participant')
result = []
timezone = get_timezone_for_user(None, domain) # Use project timezone only
current_date = datetime.now(tz=timezone).date()
for case in cases:
study_arm = case.get_case_property("study_arm")
if isinstance(study_arm, basestring) and study_arm.upper() == "A" and not case.closed:
start_date = get_date(case, "start_date")
if start_date is None:
continue
end_date = start_date + timedelta(days=55)
if start_date <= current_date <= end_date:
result.append(case)
return result
def download_location_reassignment_template(request, domain):
location_id = request.GET.get('location_id')
if not location_id or not user_can_access_location_id(domain, request.couch_user, location_id):
messages.error(request, _("Please select a location."))
return HttpResponseRedirect(reverse(LocationReassignmentView.urlname, args=[domain]))
location = SQLLocation.active_objects.get(location_id=location_id, domain=domain)
response_file = DownloadUsers(location).dump()
response = HttpResponse(response_file, content_type="text/html; charset=utf-8")
timezone = get_timezone_for_user(request.couch_user, domain)
creation_time = datetime.now(timezone).strftime(FILENAME_DATETIME_FORMAT)
filename = f"[{domain}] {location.name} Location Reassignment Request Template {creation_time}"
response['Content-Disposition'] = safe_filename_header(filename, 'xlsx')
return response
def __init__(self, request, base_context=None, domain=None, **kwargs):
super(OdmExportReportView, self).__init__(request, base_context, domain, **kwargs)
tz = get_timezone_for_user(None, self.domain)
now = datetime.now(tz)
file_oid = now.strftime('CommCare_%Y%m%d%H%M%S%z')
utc_offset = now.strftime('%z')
with_colon = ':'.join((utc_offset[:-2], utc_offset[-2:])) # Change UTC offset from "+0200" to "+02:00"
self.study_details = {
'file_oid': file_oid,
'file_description': 'Data imported from CommCare',
'creation_datetime': now.strftime('%Y-%m-%dT%H:%M:%S') + with_colon,
'study_name': get_study_constant(domain, 'study_name'),
'study_description': get_study_constant(domain, 'study_description'),
'protocol_name': get_study_constant(domain, 'protocol_name'),
'study_oid': get_study_constant(domain, 'study_oid'),
'audit_logs': AUDIT_LOGS,
}
def get_apps_base_context(request, domain, app):
lang, langs = get_langs(request, app)
if getattr(request, 'couch_user', None):
timezone = get_timezone_for_user(request.couch_user, domain)
else:
timezone = None
context = {
'lang': lang,
'langs': langs,
'domain': domain,
'app': app,
'URL_BASE': get_url_base(),
'timezone': timezone,
}
if app:
v2_app = app.application_version == APP_V2
context.update({
'show_care_plan': (
v2_app
and not app.has_careplan_module
and toggles.APP_BUILDER_CAREPLAN.enabled(request.user.username)
),
'show_advanced': (
v2_app
and (
toggles.APP_BUILDER_ADVANCED.enabled(request.user.username)
or getattr(app, 'commtrack_enabled', False)
)
),
'show_shadow_modules': (
v2_app
and toggles.APP_BUILDER_SHADOW_MODULES.enabled(domain)
),
})
return context
def project_timezone(self):
return get_timezone_for_user(None, self.domain)
def _format_last_sync_time(restore_user, sync_time=None):
sync_time = sync_time or _utcnow()
timezone = get_timezone_for_user(restore_user._couch_user,
restore_user.domain)
return ServerTime(sync_time).user_time(timezone).done().isoformat()
def get_project_time_info(domain):
timezone = get_timezone_for_user(None, domain)
now = pytz.utc.localize(datetime.utcnow())
timezone_now = now.astimezone(timezone)
return (timezone, now, timezone_now)
def project_timezone(self):
return get_timezone_for_user(None, self.domain)
def paginate_releases(request, domain, app_id):
limit = request.GET.get('limit')
only_show_released = json.loads(request.GET.get('only_show_released', 'false'))
build_comment = request.GET.get('build_comment')
page = int(request.GET.get('page', 1))
page = max(page, 1)
try:
limit = int(limit)
except (TypeError, ValueError):
limit = 10
skip = (page - 1) * limit
timezone = get_timezone_for_user(request.couch_user, domain)
def _get_batch(start_build=None, skip=None):
start_build = {} if start_build is None else start_build
return Application.get_db().view('app_manager/saved_app',
startkey=[domain, app_id, start_build],
endkey=[domain, app_id],
descending=True,
limit=limit,
skip=skip,
wrapper=lambda x: SavedAppBuild.wrap(x['value'],
scrap_old_conventions=False).releases_list_json(timezone),
).all()
if not bool(only_show_released or build_comment):
# If user is limiting builds by released status or build comment, it's much
# harder to be performant with couch. So if they're not doing so, take shortcuts.
total_apps = len(get_built_app_ids_for_app_id(domain, app_id))
saved_apps = _get_batch(skip=skip)
else:
app_es = (
AppES()
.start((page - 1) * limit)
.size(limit)
.sort('version', desc=True)
.domain(domain)
.is_build()
.app_id(app_id)
)
if only_show_released:
app_es = app_es.is_released()
if build_comment:
app_es = app_es.build_comment(build_comment)
results = app_es.exclude_source().run()
app_ids = results.doc_ids
apps = get_docs(Application.get_db(), app_ids)
saved_apps = [
SavedAppBuild.wrap(app, scrap_old_conventions=False).releases_list_json(timezone)
for app in apps
]
total_apps = results.total
j2me_enabled_configs = CommCareBuildConfig.j2me_enabled_config_labels()
for app in saved_apps:
app['include_media'] = app['doc_type'] != 'RemoteApp'
app['j2me_enabled'] = app['menu_item_label'] in j2me_enabled_configs
app['target_commcare_flavor'] = (
SavedAppBuild.get(app['_id']).target_commcare_flavor
if toggles.TARGET_COMMCARE_FLAVOR.enabled(domain)
else 'none'
)
if toggles.APPLICATION_ERROR_REPORT.enabled(request.couch_user.username):
versions = [app['version'] for app in saved_apps]
num_errors_dict = _get_error_counts(domain, app_id, versions)
for app in saved_apps:
app['num_errors'] = num_errors_dict.get(app['version'], 0)
num_pages = int(ceil(total_apps / limit))
return json_response({
'apps': saved_apps,
'pagination': {
'total': total_apps,
'num_pages': num_pages,
'current_page': page,
}
})
def _format_last_sync_time(domain, user_id, sync_time=None):
sync_time = sync_time or _utcnow()
timezone = get_timezone_for_user(user_id, domain)
return ServerTime(sync_time).user_time(timezone).done().isoformat()
def paginate_releases(request, domain, app_id):
limit = request.GET.get('limit')
only_show_released = json.loads(request.GET.get('only_show_released', 'false'))
query = request.GET.get('query')
page = int(request.GET.get('page', 1))
page = max(page, 1)
try:
limit = int(limit)
except (TypeError, ValueError):
limit = 10
skip = (page - 1) * limit
timezone = get_timezone_for_user(request.couch_user, domain)
def _get_batch(start_build=None, skip=None):
start_build = {} if start_build is None else start_build
return Application.get_db().view('app_manager/saved_app',
startkey=[domain, app_id, start_build],
endkey=[domain, app_id],
descending=True,
limit=limit,
skip=skip,
wrapper=lambda x: (
SavedAppBuild.wrap(x['value'], scrap_old_conventions=False)
.releases_list_json(timezone)
),
).all()
if not bool(only_show_released or query):
# If user is limiting builds by released status or build comment, it's much
# harder to be performant with couch. So if they're not doing so, take shortcuts.
total_apps = len(get_built_app_ids_for_app_id(domain, app_id))
saved_apps = _get_batch(skip=skip)
else:
app_es = (
AppES()
.start((page - 1) * limit)
.size(limit)
.sort('version', desc=True)
.domain(domain)
.is_build()
.app_id(app_id)
)
if only_show_released:
app_es = app_es.is_released()
if query:
app_es = app_es.add_query(build_comment(query), queries.SHOULD)
try:
app_es = app_es.add_query(version(int(query)), queries.SHOULD)
except ValueError:
pass
results = app_es.exclude_source().run()
total_apps = results.total
app_ids = results.doc_ids
apps = get_docs(Application.get_db(), app_ids)
saved_apps = [
SavedAppBuild.wrap(app, scrap_old_conventions=False).releases_list_json(timezone)
for app in apps
]
if toggles.APPLICATION_ERROR_REPORT.enabled(request.couch_user.username):
versions = [app['version'] for app in saved_apps]
num_errors_dict = _get_error_counts(domain, app_id, versions)
for app in saved_apps:
app['num_errors'] = num_errors_dict.get(app['version'], 0)
num_pages = int(ceil(total_apps / limit))
return json_response({
'apps': saved_apps,
'pagination': {
'total': total_apps,
'num_pages': num_pages,
'current_page': page,
'more': page * limit < total_apps, # needed when select2 uses this endpoint
}
})
def manage_registry(request, domain, registry_slug):
registry = _get_registry_or_404(domain, registry_slug)
if not RegistryPermissionCheck(
domain, request.couch_user).can_manage_registry(registry.slug):
return HttpResponseForbidden()
is_owner = registry.domain == domain
all_invitations = list(registry.invitations.all())
domain_invitation = [
invitation for invitation in all_invitations
if invitation.domain == domain
][0]
if is_owner:
invitations = all_invitations
grants = registry.grants.all()
available_domains = BillingAccount.get_account_by_domain(
domain).get_domains()
else:
invitations, available_domains = [], []
grants = registry.grants.filter(
Q(from_domain=domain) | Q(to_domains__contains=[domain]))
context = {
"domain": domain,
"is_owner": is_owner,
"registry": {
"domain":
registry.domain,
"current_domain":
domain,
"is_owner":
is_owner,
"name":
registry.name,
"description":
registry.description or '',
"slug":
registry.slug,
"is_active":
registry.is_active,
"schema":
registry.wrapped_schema.case_types,
"invitations": [
invitation.to_json() for invitation in invitations
if invitation.domain != domain
],
"domain_invitation":
domain_invitation,
"grants": [grant.to_json() for grant in grants]
},
"available_case_types":
list(get_data_dict_case_types(registry.domain)),
"available_domains": available_domains,
"invited_domains":
[invitation.domain for invitation in all_invitations],
"log_action_types":
DataRegistryAuditViewHelper.action_options(is_owner),
"user_timezone": get_timezone_for_user(request.couch_user, domain),
"current_page": {
"title":
_("Manage Registry"),
"page_name":
_("Manage Registry"),
"parents": [
{
"title": _("Data Registries"),
"page_name": _("Data Registries"),
"url": reverse("data_registries", args=[domain]),
},
],
},
'section': {
'page_name': _('Project Settings'),
'url': reverse("domain_settings_default", args=[domain]),
},
}
return render(request, "registry/registry_edit.html", context)
def _last_sync_time(domain, user_id):
timezone = get_timezone_for_user(user_id, domain)
return ServerTime(_utcnow()).user_time(timezone).done().isoformat()
def test_no_user(self, _):
self.assertEqual(get_timezone_for_user(None, "test"), DOMAIN_TIMEZONE)
def test_user_with_no_domain_membership(self, domain_membership_mock):
couch_user = WebUser()
domain_membership_mock.return_value = None
self.assertEqual(get_timezone_for_user(couch_user, "test"),
DOMAIN_TIMEZONE)
def _last_sync_time(domain, user_id):
timezone = get_timezone_for_user(user_id, domain)
return ServerTime(_utcnow()).user_time(timezone).done().isoformat()
def paginate_releases(request, domain, app_id):
limit = request.GET.get('limit')
only_show_released = json.loads(
request.GET.get('only_show_released', 'false'))
query = request.GET.get('query')
page = int(request.GET.get('page', 1))
page = max(page, 1)
try:
limit = int(limit)
except (TypeError, ValueError):
limit = 10
skip = (page - 1) * limit
timezone = get_timezone_for_user(request.couch_user, domain)
def _get_batch(start_build=None, skip=None):
start_build = {} if start_build is None else start_build
return Application.get_db().view(
'app_manager/saved_app',
startkey=[domain, app_id, start_build],
endkey=[domain, app_id],
descending=True,
limit=limit,
skip=skip,
wrapper=lambda x:
(SavedAppBuild.wrap(x['value'], scrap_old_conventions=False).
releases_list_json(timezone)),
).all()
if not bool(only_show_released or query):
# If user is limiting builds by released status or build comment, it's much
# harder to be performant with couch. So if they're not doing so, take shortcuts.
total_apps = len(get_built_app_ids_for_app_id(domain, app_id))
saved_apps = _get_batch(skip=skip)
else:
app_es = (AppES().start((page - 1) * limit).size(limit).sort(
'version', desc=True).domain(domain).is_build().app_id(app_id))
if only_show_released:
app_es = app_es.is_released()
if query:
app_es = app_es.add_query(build_comment(query), queries.SHOULD)
try:
app_es = app_es.add_query(version(int(query)), queries.SHOULD)
except ValueError:
pass
results = app_es.exclude_source().run()
total_apps = results.total
app_ids = results.doc_ids
apps = get_docs(Application.get_db(), app_ids)
saved_apps = [
SavedAppBuild.wrap(
app, scrap_old_conventions=False).releases_list_json(timezone)
for app in apps
]
if toggles.APPLICATION_ERROR_REPORT.enabled(request.couch_user.username):
versions = [app['version'] for app in saved_apps]
num_errors_dict = _get_error_counts(domain, app_id, versions)
for app in saved_apps:
app['num_errors'] = num_errors_dict.get(app['version'], 0)
num_pages = int(ceil(total_apps / limit))
return json_response({
'apps': saved_apps,
'pagination': {
'total': total_apps,
'num_pages': num_pages,
'current_page': page,
'more': page * limit <
total_apps, # needed when select2 uses this endpoint
}
})
def get_apps_base_context(request, domain, app):
lang, langs = get_langs(request, app)
if getattr(request, 'couch_user', None):
timezone = get_timezone_for_user(request.couch_user, domain)
else:
timezone = None
context = {
'lang': lang,
'langs': langs,
'domain': domain,
'app': app,
'app_subset': {
'commcare_minor_release':
app.commcare_minor_release,
'doc_type':
app.get_doc_type(),
'form_counts_by_module':
[len(m.forms)
for m in app.modules] if not app.is_remote_app() else [],
'version':
app.version,
} if app else {},
'timezone': timezone,
}
if app and not app.is_remote_app():
app.assert_app_v2()
show_advanced = (toggles.APP_BUILDER_ADVANCED.enabled(domain)
or getattr(app, 'commtrack_enabled', False))
show_biometric = (toggles.BIOMETRIC_INTEGRATION.enabled(domain)
and app.is_biometric_enabled)
disable_report_modules = (
is_master_linked_domain(domain)
and not toggles.MOBILE_UCR_LINKED_DOMAIN.enabled(domain))
# ideally this should be loaded on demand
practice_users = []
if app.enable_practice_users:
try:
practice_users = get_practice_mode_mobile_workers(
request.domain)
except ESError:
notify_exception(request,
'Error getting practice mode mobile workers')
latest_version_for_build_profiles = {}
if toggles.RELEASE_BUILDS_PER_PROFILE.enabled(domain):
latest_version_for_build_profiles = get_latest_enabled_versions_per_profile(
app.get_id)
context.update({
'show_advanced':
show_advanced,
'show_biometric':
show_biometric,
'show_report_modules':
toggles.MOBILE_UCR.enabled(domain),
'disable_report_modules':
disable_report_modules,
'show_shadow_modules':
toggles.APP_BUILDER_SHADOW_MODULES.enabled(domain),
'show_shadow_forms':
show_advanced,
'show_training_modules':
toggles.TRAINING_MODULE.enabled(domain)
and app.enable_training_modules,
'practice_users': [{
"id": u['_id'],
"text": u["username"]
} for u in practice_users],
'latest_version_for_build_profiles':
latest_version_for_build_profiles,
})
return context
def get_project_time_info(domain):
timezone = get_timezone_for_user(None, domain)
now = pytz.utc.localize(datetime.utcnow())
timezone_now = now.astimezone(timezone)
return (timezone, now, timezone_now)
