def distribution_chart(pos: int):
from .query import Query
query = Query.from_dict(flask.request.json)
column = list(query.data_set.columns.values())[pos]
if not current_user_has_permission(query):
return flask.make_response(acl.inline_permission_denied_message(), 403)
elif column.column_name in query.data_set.personal_data_column_names \
and not acl.current_user_has_permission(personal_data_acl_resource):
return flask.make_response(
acl.inline_permission_denied_message('Restricted personal data'), 403)
else:
if column.type == 'number':
data = query.number_distribution(column.column_name)
elif column.type == 'text':
data = query.text_distribution(column.column_name)
elif column.type == 'text[]':
data = query.text_array_distribution(column.column_name)
elif column.type == 'date':
data = query.date_distribution(column.column_name)
else:
data = []
return flask.jsonify({'column': column.to_dict(), 'data': data})
def preview():
from .query import Query
from .data_set import Column
query = Query.from_dict(flask.request.json['query'])
def header(column: Column):
if column.sortable():
if query.sort_column_name == column.column_name and query.sort_order == 'ASC':
icon = _.span(class_=('fa fa-sort-amount-asc'))['']
elif query.sort_column_name == column.column_name and query.sort_order == 'DESC':
icon = _.span(class_=('fa fa-sort-amount-desc'))['']
else:
icon = ''
return _.a(href="#", name=flask.escape(column.column_name))[
icon, ' ',
flask.escape(column.column_name)]
else:
return flask.escape(column.column_name)
if current_user_has_permission(query):
rows = [_render_preview_row(query, row)
for row in query.run(limit=flask.request.json['limit'], offset=flask.request.json['offset'],
include_personal_data=acl.current_user_has_permission(personal_data_acl_resource))]
else:
rows = _.tr[_.td(colspan=len(query.column_names))[acl.inline_permission_denied_message()]]
if rows:
return str(bootstrap.table(headers=[header(query.data_set.columns[c]) for c in query.column_names], rows=rows))
else:
return '∅'
def __(task: pipelines.ParallelTask):
if not acl.current_user_has_permission(views.acl_resource):
return bootstrap.card(
header_left=acl.inline_permission_denied_message())
else:
return [
bootstrap.card(header_left='Commands before',
fixed_header_height=True,
sections=[
_render_command(command)
for command in task.commands_before
]) if task.commands_before else '',
bootstrap.card(header_left='Sub task creation',
body=bootstrap.table([], [
_.tr[_.td[_.div[section]],
_.td(style='width:90%')[content]]
for section, content in task.html_doc_items()
])),
bootstrap.card(header_left='Commands after',
fixed_header_height=True,
sections=[
_render_command(command)
for command in task.commands_after
]) if task.commands_after else ''
]
def filter_row_count(filter_pos):
query = Query.from_dict(flask.request.json)
if current_user_has_permission(query):
return flask.jsonify(query.filter_row_count(filter_pos))
else:
return flask.make_response(acl.inline_permission_denied_message(), 403)
def __(task: pipelines.Task):
if not acl.current_user_has_permission(views.acl_resource):
return bootstrap.card(header_left='Commands', body=acl.inline_permission_denied_message())
else:
return bootstrap.card(
header_left='Commands',
fixed_header_height=True,
sections=[_render_command(command) for command in task.commands])
def row_count():
from .query import Query
query = Query.from_dict(flask.request.json)
if current_user_has_permission(query):
return flask.jsonify(query.row_count())
else:
return flask.make_response(acl.inline_permission_denied_message(), 403)
def data_set_preview(data_set_id):
query = Query(data_set_id=data_set_id)
if not current_user_has_permission(query):
return acl.inline_permission_denied_message()
else:
if current_user_has_permission(query):
rows = [
_render_preview_row(query, row) for row in query.run(
limit=7,
offset=0,
include_personal_data=acl.current_user_has_permission(
personal_data_acl_resource))
]
else:
rows = _.tr[_.td(colspan=len(query.column_names))[
acl.inline_permission_denied_message()]]
return str(
bootstrap.table(headers=[
flask.escape(column_name) for column_name in query.column_names
],
rows=rows))
def _render_preview_row(query, row):
values = []
for pos, value in enumerate(row):
if value == '🔒':
values.append(acl.inline_permission_denied_message('Restricted personal data'))
elif query.column_names[pos] in query.data_set.custom_column_renderers:
values.append(query.data_set.custom_column_renderers[query.column_names[pos]](value))
elif not value:
values.append('')
elif query.data_set.columns[query.column_names[pos]].type == 'text[]':
values.append(_.ul[[_.li[_.span(class_='preview-value')[str(array_element)]] for array_element in value]])
elif query.data_set.columns[query.column_names[pos]].type == 'json':
values.append(_.pre(class_='preview-value')[flask.escape(json.dumps(value, indent=2))])
else:
values.append(_.span(class_='preview-value')[str(value)])
return _.tr[[_.td[value] for value in values]]
def oauth2_export_to_google_sheet():
try:
import google_auth_oauthlib.flow
import googleapiclient.discovery
except ImportError:
return flask.make_response(
str(_.tt(style='color:red')[
"Please install the packages 'google_auth_oauthlib' and 'google-api-python-client'"]),
500)
os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'
from .query import Query
query = Query.from_dict(json.loads(flask.request.form['query']))
if current_user_has_permission(query):
flask.session['query_for_google_sheet_callback'] = json.loads(flask.request.form['query']) # flask.request.json
# Authorization
flow = google_auth_oauthlib.flow.Flow.from_client_config(
config.google_sheet_oauth2_client_config(),
scopes=SCOPES)
# Indicate where the API server will redirect the user after the user completes
# the authorization flow. Required.
flow.redirect_uri = flask.url_for('mara_data_explorer.google_sheet_oauth2callback', _external=True)
# Generate URL for request to Google's OAuth 2.0 server
authorization_url, state = flow.authorization_url(
# Enable offline access so that you can refresh an access token without
# re-prompting the user for permission. Recommended for web server apps.
access_type='offline',
# Enable incremental authorization. Recommended as a best practice
include_granted_scopes='true')
# Store the state so the callback can verify the auth server response.
flask.session['state'] = state
# Store parameters for callback
flask.session['decimal_mark'] = flask.request.form['decimal-mark']
flask.session['array_format'] = flask.request.form['array-format']
return flask.redirect(authorization_url)
else:
return flask.make_response(acl.inline_permission_denied_message(), 403)
