def get(self, request, domain, app_id, **kwargs):
app_access = get_application_access_for_domain(domain)
app = get_current_app(domain, app_id)
if not app_access.user_can_access_app(request.couch_user, app):
raise Http404()
def _default_lang():
try:
return app['langs'][0]
except Exception:
return 'en'
# default language to user's preference, followed by
# first app's default, followed by english
language = request.couch_user.language or _default_lang()
domain_obj = Domain.get_by_name(domain)
context = {
"domain": domain,
"default_geocoder_location": domain_obj.default_geocoder_location,
"language": language,
"apps": [_format_app_doc(app)],
"mapbox_access_token": settings.MAPBOX_ACCESS_TOKEN,
"username": request.user.username,
"formplayer_url": get_formplayer_url(for_js=True),
"single_app_mode": True,
"home_url": reverse(self.urlname, args=[domain, app_id]),
"environment": WEB_APPS_ENVIRONMENT,
"integrations": integration_contexts(domain),
"has_geocoder_privs": has_geocoder_privs(domain),
}
return render(request, "cloudcare/formplayer_home.html", context)
def validate_form(form_xml):
try:
response = requests.post(get_formplayer_url() +
const.ENDPOINT_VALIDATE_FORM,
data=form_xml,
headers={'Content-Type': 'application/xml'})
except RequestException as e:
notify_exception(None,
"Error calling Formplayer form validation endpoint")
raise FormplayerAPIException(e)
try:
response.raise_for_status()
except HTTPError:
notify_exception(None,
"Error calling Formplayer form validation endpoint",
details={'status_code': response.status_code})
raise FormplayerRequestException(response.status_code)
api_result = ValidationAPIResult(response.json())
result = FormValidationResult(
problems=[problem.to_json() for problem in api_result.problems],
success=api_result.validated,
fatal_error=api_result.fatal_error,
)
return result
def get_main(self, request, domain):
restore_as, set_cookie = self.get_restore_as_user(request, domain)
apps = self.get_web_apps_available_to_user(domain, restore_as)
def _default_lang():
try:
return apps[0]['langs'][0]
except Exception:
return 'en'
# default language to user's preference, followed by
# first app's default, followed by english
language = request.couch_user.language or _default_lang()
domain_obj = Domain.get_by_name(domain)
context = {
"domain": domain,
"default_geocoder_location": domain_obj.default_geocoder_location,
"language": language,
"apps": apps,
"domain_is_on_trial": domain_is_on_trial(domain),
"mapbox_access_token": settings.MAPBOX_ACCESS_TOKEN,
"username": request.couch_user.username,
"formplayer_url": get_formplayer_url(for_js=True),
"single_app_mode": False,
"home_url": reverse(self.urlname, args=[domain]),
"environment": WEB_APPS_ENVIRONMENT,
"integrations": integration_contexts(domain),
"has_geocoder_privs": has_geocoder_privs(domain),
}
return set_cookie(
render(request, "cloudcare/formplayer_home.html", context))
def validate_form(form_xml):
try:
response = requests.post(
get_formplayer_url() + const.ENDPOINT_VALIDATE_FORM,
data=form_xml,
headers={'Content-Type': 'application/xml'}
)
except RequestException as e:
notify_exception(None, "Error calling Formplayer form validation endpoint")
raise FormplayerAPIException(e)
try:
response.raise_for_status()
except HTTPError:
notify_exception(None, "Error calling Formplayer form validation endpoint", details={
'status_code': response.status_code
})
raise FormplayerRequestException(response.status_code)
api_result = ValidationAPIResult(response.json())
result = FormValidationResult(
problems=[problem.to_json() for problem in api_result.problems],
success=api_result.validated,
fatal_error=api_result.fatal_error,
)
return result
def check_formplayer():
try:
res = requests.get('{}/serverup'.format(get_formplayer_url()), timeout=5)
except requests.exceptions.ConnectTimeout:
return ServiceStatus(False, "Could not establish a connection in time")
except requests.ConnectionError:
return ServiceStatus(False, "Could not connect to formplayer")
else:
msg = "Formplayer returned a {} status code".format(res.status_code)
return ServiceStatus(res.ok, msg)
def check_formplayer():
try:
# Setting verify=False in this request keeps this from failing for urls with self-signed certificates.
# Allowing this because the certificate will always be self-signed in the "provable deploy"
# bootstrapping test in commcare-cloud.
res = requests.get('{}/serverup'.format(get_formplayer_url()), timeout=5, verify=False)
except requests.exceptions.ConnectTimeout:
return ServiceStatus(False, "Could not establish a connection in time")
except requests.ConnectionError:
return ServiceStatus(False, "Could not connect to formplayer")
else:
msg = "Formplayer returned a {} status code".format(res.status_code)
return ServiceStatus(res.ok, msg)
def post_data(data, auth=None, content_type="application/json"):
try:
d = json.loads(data)
except TypeError:
raise BadDataError('unhandleable touchforms query: %s' % data)
domain = d.get("domain")
if not domain:
raise ValueError("Expected domain")
d = get_formplayer_session_data(d)
return formplayer_post_data_helper(d, content_type, get_formplayer_url() + "/" + d["action"])
def post_data(data, auth=None, content_type="application/json"):
try:
d = json.loads(data)
except TypeError:
raise BadDataError('unhandleable touchforms query: %s' % data)
domain = d.get("domain")
if not domain:
raise ValueError("Expected domain")
d = get_formplayer_session_data(d)
return formplayer_post_data_helper(d, content_type, get_formplayer_url() + "/" + d["action"])
def check_formplayer():
try:
# Setting verify=False in this request keeps this from failing for urls with self-signed certificates.
# Allowing this because the certificate will always be self-signed in the "provable deploy"
# bootstrapping test in commcare-cloud.
res = requests.get('{}/serverup'.format(get_formplayer_url()), timeout=5, verify=False)
except requests.exceptions.ConnectTimeout:
return ServiceStatus(False, "Could not establish a connection in time")
except requests.ConnectionError:
return ServiceStatus(False, "Could not connect to formplayer")
else:
msg = "Formplayer returned a {} status code".format(res.status_code)
return ServiceStatus(res.ok, msg)
def get(self, request, *args, **kwargs):
app = get_app(request.domain, kwargs.pop('app_id'))
return self.render_to_response({
'app':
_format_app_doc(app.to_json()),
'formplayer_url':
get_formplayer_url(for_js=True),
"mapbox_access_token":
settings.MAPBOX_ACCESS_TOKEN,
"environment":
PREVIEW_APP_ENVIRONMENT,
"integrations":
integration_contexts(request.domain),
"has_geocoder_privs":
has_geocoder_privs(request.domain),
})
def perform_experiment(data, auth, content_type):
should_experiment, candidate_data = get_candidate_session_data(data)
if not should_experiment:
return post_data_helper(data, auth, content_type, settings.XFORMS_PLAYER_URL)
experiment = FormplayerExperiment(name=data["action"], context={'request': data})
with experiment.control() as c:
c.record(post_data_helper(data, auth, content_type, settings.XFORMS_PLAYER_URL))
with experiment.candidate() as c:
formplayer_url = get_formplayer_url()
c.record(formplayer_post_data_helper(candidate_data, auth,
content_type, formplayer_url + "/" + data["action"]))
objects = experiment.run()
return objects
def post_data(data, auth=None, content_type="application/json"):
try:
d = json.loads(data)
except TypeError:
raise BadDataError('unhandleable touchforms query: %s' % data)
if auth:
d['hq_auth'] = auth.to_dict()
# just default to old server for now
domain = d.get("domain")
if not domain:
raise ValueError("Expected domain")
if toggles.SMS_USE_FORMPLAYER.enabled(domain):
logging.info("Making request to formplayer endpoint %s in domain %s" % (d["action"], domain))
d = get_formplayer_session_data(d)
return formplayer_post_data_helper(d, auth, content_type, get_formplayer_url() + "/" + d["action"])
return perform_experiment(d, auth, content_type)
def _post_data(data, user_id):
if not data.get("domain"):
raise ValueError("Expected domain")
if not user_id:
notify_exception(
None,
"Making smsforms request w/o user_id. Will result in non-sticky session.",
details={
'session-id': data.get('session-id'),
})
data = _get_formplayer_session_data(data)
data_bytes = json.dumps(data).encode('utf-8')
response = requests.post(
url="{}/{}".format(get_formplayer_url(), data["action"]),
data=data_bytes,
headers={
"Content-Type":
"application/json",
"content-length":
str(len(data_bytes)),
"X-MAC-DIGEST":
get_hmac_digest(settings.FORMPLAYER_INTERNAL_AUTH_KEY, data_bytes),
"X-FORMPLAYER-SESSION":
user_id,
},
)
if response.status_code == 404:
raise Http404(response.reason)
if 500 <= response.status_code < 600:
http_error_msg = '{} Server Error: {} for url: {}'.format(
response.status_code, response.reason, response.url)
notify_error(http_error_msg,
details={
'response': response,
'body': response.text
})
raise HTTPError(http_error_msg, response=response)
return response.json()
form_name = list(form.name.values())[0]
# make the name for the session we will use with the case and form
session_name = '{app} > {form}'.format(
app=app.name,
form=form_name,
)
if case_id:
case = CommCareCase.objects.get_case(case_id, domain)
session_name = '{0} - {1}'.format(session_name, case.name)
root_context = {
'form_url': form_url,
'formplayer_url': get_formplayer_url(for_js=True),
}
if instance_id:
try:
root_context['instance_xml'] = XFormInstance.objects.get_form(
instance_id, domain).get_xml()
except XFormNotFound:
raise Http404()
session_extras = {'session_name': session_name, 'app_id': app._id}
session_extras.update(
get_cloudcare_session_data(domain, form, request.couch_user))
delegation = request.GET.get('task-list') == 'true'
session_helper = CaseSessionDataHelper(domain,
request.couch_user,
