def get_single_stat_view(request):
"""
Get a single_stat
:param request:
:return:
"""
return get(request, SingleStat)
def get_data_source_view(request):
"""
Get a data_source
:param request:
:return:
"""
return get(request, DataSource)
def get_query_view(request):
"""
Get a query
:param request:
:return:
"""
return get(request, Query)
def get_chart_view(request):
"""
Get a chart
:param request:
:return:
"""
return get(request, Chart)
def get_variable_view(request):
"""
Get a variable
:param request:
:return:
"""
return get(request, Variable)
def get_dashboard_view(request):
"""
Get a dashboard
:param request:
:return:
"""
dashboard = get(request, Dashboard, as_dict=False)
return dashboard.as_dict(request.authenticated_userid)
def paste_single_stat_view(request):
"""
Paste a SingleStat view
:param request:
:return SingleStat:
"""
single_stat = get(request, SingleStat, as_dict=False)
data = {attr: getattr(single_stat, attr) for attr in attrs}
pasted_stat = paste(request, SingleStat, data, 'dashboard_id', 'title')
return pasted_stat.as_dict()
def edit_data_source_view(request):
"""
Edit data_source
:param request:
:return:
"""
data_source = get(request, DataSource, as_dict=False)
data = get_values(request, attrs, required_attrs)
edit(data_source, **data)
return data_source.as_dict()
def edit_query_view(request):
"""
Edit query
:param request:
:return:
"""
query = get(request, Query, as_dict=False)
data = get_values(request, attrs, required_attrs)
edit(query, **data)
return query.as_dict()
def edit_collection(request):
"""
Edit collection
:param request:
:return:
"""
collection = get(request, Collection, as_dict=False)
data = get_values(request, attrs, required_attrs)
edit(collection, **data)
return collection.as_dict(request.authenticated_userid)
def reorder_chart_view(request):
"""
Delete a chart view
:param request:
:return:
"""
chart = get(request, Chart, as_dict=False)
data = get_values(request, ['index'], ['index'])
dashboard_charts = session.query(Chart).filter(
chart.dashboard_id == chart.dashboard_id)
reorder(data.get('index'), chart, Chart, dashboard_charts)
return {}
def query(request):
"""
Get chart data using data source query
:param request:
:return:
"""
data_source = get(request, DataSource, as_dict=False)
query_string = request.json_body.get('query', '')
# query formatted in front end
# run http or database query
return format_run_query(request, query_string, {}, None, data_source)
def edit_dashboard_view(request):
"""
Edit dashboard
:param request:
:return:
"""
dashboard = get(request, Dashboard, as_dict=False)
data = get_values(request, attrs, required_attrs)
edit(dashboard, **data)
return dashboard.as_dict(request.authenticated_userid)
def reorder_dashboard_view(request):
"""
Reorder a dashboard in a list view
:param request:
:return Dashboard:
"""
dashboard = get(request, Dashboard, as_dict=False)
data = get_values(request, ['index'], ['index'])
collection_dashboards = session.query(Dashboard).filter(
Dashboard.collection_id == dashboard.collection_id)
reorder(data.get('index'), dashboard, Dashboard, collection_dashboards)
return {}
def edit_user(request):
"""
Edit user
:param request:
:return:
"""
user_id = request.matchdict.get('id')
email = request.json_body.get('email')
telephone = request.json_body.get('telephone')
password = request.json_body.get('password')
role = request.json_body.get('role')
user = get(request, User, as_dict=False)
data = get_values(request, attrs, required_attrs)
# only admin or owner of user profile can edit profile
if user_id != request.authenticated_userid:
admin_user = get_user(user_id=request.authenticated_userid, role=Administrator)
if not admin_user:
raise exc.HTTPForbidden()
if telephone:
usr = get_user(telephone=telephone)
if usr and (usr.id != user_id):
raise exc.HTTPBadRequest(json_body={'message': 'User with telephone number %s already exists' % telephone})
if email:
usr = get_user(email=email)
if usr and (usr.id != user_id):
raise exc.HTTPBadRequest(json_body={'message': 'User with email %s already exists' % email})
if not request.json_body.get('role'):
raise exc.HTTPBadRequest(json_body={'message': 'User role is required'})
if request.json_body.get('confirmed_registration') is None:
data['confirmed_registration'] = False
edit(user, **data)
if password:
user.set_password(password)
# update user role
existing_role = session.query(Role).filter(Role.name == role).first()
user_role = session.query(UserRole).filter(UserRole.user_id == user_id, UserRole.role_id == existing_role.id).first()
if not user_role:
user.roles = []
user.roles.append(existing_role)
return user.as_dict()
def get_user_view(request):
"""
Get a user
:param request:
:return:
"""
user_id = request.matchdict.get('id')
# only admin can load other users
if user_id != request.authenticated_userid:
admin_user = get_user(request.authenticated_userid, role=Administrator)
if not admin_user:
raise exc.HTTPForbidden()
return get(request, User)
def paste_dashboard_view(request):
"""
Paste a dashboard view
:param request:
:return Dashboard:
"""
dashboard = get(request, Dashboard, as_dict=False)
data = {attr: getattr(dashboard, attr) for attr in attrs}
pasted_dashboard = paste(request, Dashboard, data, 'collection_id',
'title')
_paste_dashboard_relationships(dashboard, pasted_dashboard)
return pasted_dashboard.as_dict(request.authenticated_userid)
def edit_chart(request):
"""
Edit chart
:param request:
:return:
"""
chart = get(request, Chart, as_dict=False)
data = get_values(request, attrs, required_attrs)
edit(chart, **data)
group_by = request.json_body.get('group_by', [])
for group in chart.group_by:
for data in group_by:
if data['dashboard_view_id'] == group.dashboard_view_id:
group.value = data['value']
break
return chart.as_dict()
def paste_chart_view(request):
"""
Paste a chart view
:param request:
:return Chart:
"""
chart = get(request, Chart, as_dict=False)
data = {attr: getattr(chart, attr) for attr in attrs}
pasted_chart = paste(request, Chart, data, 'dashboard_id', 'title')
for group in chart.group_by:
create(ChartGroupBy,
chart_id=pasted_chart.id,
dashboard_view_id=group.dashboard_view_id,
value=group.value)
return pasted_chart.as_dict()
def edit_single_stat_view(request):
"""
Edit single_stat
:param request:
:return:
"""
single_stat = get(request, SingleStat, as_dict=False)
thresholds = request.json_body.get('thresholds', '')
colors = request.json_body.get('colors', '')
# check threshold and colors values
if len(thresholds.split(',')) != len(colors.split(',')) - 1:
raise exc.HTTPBadRequest(
json_body={'message': 'Need one more color than thresholds'})
data = get_values(request, attrs, required_attrs)
edit(single_stat, **data)
return single_stat.as_dict()
def edit_variable_view(request):
"""
Edit variable
:param request:
:return:
"""
variable = get(request, Variable, as_dict=False)
name = request.json_body.get('name')
existing = session.query(Variable).filter_by(
name=name, container_id=variable.container_id).first()
if existing and existing.id != variable.id:
raise exc.HTTPBadRequest(
json_body={
'message': 'Variable with name %s already exists' % name
})
data = get_values(request, attrs, required_attrs)
edit(variable, **data)
return variable.as_dict()
def get_collection_view(request):
"""
Get a collection
:param request:
:return:
"""
collection = get(request, Collection, as_dict=False)
collection_data = collection.as_dict(request.authenticated_userid)
# include user dashboards with access
user = get_user(request.authenticated_userid)
dashboards = session.query(Dashboard).filter(
Dashboard.collection_id == collection.id)
if not user.has_role(Administrator):
dashboards = dashboards.join(
Dashboard.users).filter(User.id == request.authenticated_userid)
collection_data['dashboards'] = [
dash.as_dict(request.authenticated_userid)
for dash in dashboards.all()
]
return collection_data
def paste_collection_view(request):
"""
Paste a Collection view
:param request:
:return Collection:
"""
collection = get(request, Collection, as_dict=False)
data = {attr: getattr(collection, attr) for attr in attrs}
pasted_collection = paste(request, Collection, data, None, 'title')
# copy list of users
user_access = session.query(UserCollection).filter(
UserCollection.collection_id == collection.id).all()
for access in user_access:
create(UserCollection,
user_id=access.user_id,
collection_id=pasted_collection.id,
role_id=access.role_id)
# copy list of variables
for variable in collection.variables:
create(Variable,
name=variable.name,
value=variable.value,
container_id=pasted_collection.id)
# copy dashboards in collection
for dashboard in collection.dashboards:
data = {attr: getattr(dashboard, attr) for attr in dashboard_attrs}
data['collection_id'] = pasted_collection.id
data['index'] = dashboard.index
pasted_dashboard = create(Dashboard, **data)
_paste_dashboard_relationships(dashboard, pasted_dashboard)
return pasted_collection.as_dict()
def get_content_view(request):
""" Return dashboard content """
dashboard = get(request, Dashboard, as_dict=False)
return Response(dashboard.content)
def edit_content_view(request):
""" Return dashboard content """
dashboard = get(request, Dashboard, as_dict=False)
content = request.json_body.get('content', '')
edit(dashboard, content=content)
return Response(dashboard.content)
