def get_authorization_header(request):
"""
Get HTTP authorization header
:param request: request
:type request: str
:returns http status: string
"""
auth = request.META.get("HTTP_AUTHORIZATION", None)
if auth is None:
try:
auth = get_auth_header(request.user.social_auth.get())
# logger.debug("Got authorization from database")
except AttributeError:
pass
# in case of 401 error, need to trap and redirect to login
else:
if request.META.get("HTTP_AUTHORIZATION",
None).split(" ")[0].lower() == "bearer":
auth = request.META.get("HTTP_AUTHORIZATION", None)
else:
auth = "Bearer " + request.META.get("HTTP_AUTHORIZATION", None)
# logger.debug("Got authorization from HTTP header")
return {'Authorization': auth}
def home(request):
ctx = get_url_ctx(request)
#to get app_id
social_auth = request.user.social_auth.get()
headers = {
'Authorization': get_auth_header(request.user.social_auth.get())
}
#to get collab_id
svc_url = settings.HBP_COLLAB_SERVICE_URL
url = '%scollab/context/%s/' % (svc_url, ctx)
res = requests.get(url, headers=headers)
try :
app_id = res.json()['id']
except :
return render(request, 'welcome.html', {})
app_params=list(CollabParameters.objects.filter(id = app_id).values('app_type'))
if app_params != []:
if app_params[0]["app_type"]=="model_catalog":
return render(request, 'model_catalog/model_catalog.html', {})
else:
if app_params[0]["app_type"]=="validation_app":
return render(request, 'validation_framework/validation_home.html', {})
return render(request, 'home.html', {})
def home(request):
ctx = get_url_ctx(request)
#to get app_id
social_auth = request.user.social_auth.get()
headers = {
'Authorization': get_auth_header(request.user.social_auth.get())
}
#to get collab_id
svc_url = settings.HBP_COLLAB_SERVICE_URL
url = '%scollab/context/%s/' % (svc_url, ctx)
res = requests.get(url, headers=headers)
try :
app_id = res.json()['id']
except :
return render(request, 'welcome.html', {})
app_params=list(CollabParameters.objects.filter(id = app_id).values('app_type'))
if app_params != []:
if app_params[0]["app_type"]=="model_catalog":
return render(request, 'model_catalog/model_catalog.html', {})
else:
if app_params[0]["app_type"]=="validation_app":
return render(request, 'validation_framework/validation_home.html', {})
return render(request, 'home.html', {})
def get_user_info(request):
social_auth = request.user.social_auth.get()
url = "https://services.humanbrainproject.eu/oidc/userinfo"
headers = {
'Authorization': get_auth_header(request.user.social_auth.get()),
}
res = requests.post(url, headers=headers)
return res.json()
def get_user_info(request):
social_auth = request.user.social_auth.get()
url = "https://services.humanbrainproject.eu/oidc/userinfo"
headers = {
'Authorization': get_auth_header(request.user.social_auth.get()),
}
res = requests.post(url, headers=headers)
return res.json()
def _get_hbp_collab_id (request=None, context=None):
svc_url = settings.HBP_COLLAB_SERVICE_URL
url = '%scollab/context/%s/' % (svc_url, context)
headers = {'Authorization': get_auth_header(request.user.social_auth.get())}
res = requests.get(url, headers=headers)
collab_id = res.json()['collab']['id']
return (collab_id)
def get_storage_file_by_id (request):
url = "https://services.humanbrainproject.eu/storage/v1/api/file/7047b77d-10a7-45ee-903a-29fe7a8cc9e5/content/"
headers = {'Authorization': get_auth_header(request.user.social_auth.get())}
res = requests.get(url, headers=headers)
if res.status_code != 200:
return False
return res._content
def _get_collab_extension(request, context):
svc_url = settings.HBP_COLLAB_SERVICE_URL
url = '%scollab/context/%s/' % (svc_url, context)
headers = {'Authorization': get_auth_header(request.user.social_auth.get())}
res = requests.get(url, headers=headers)
return (json.loads(res._content)['collab']['title'])
def user_collab_list(my_collabs_url, social_auth):
auth_data_list = []
headers = {'Authorization': get_auth_header(social_auth)}
res_mine = requests.get(my_collabs_url, headers = headers)
resp_mine = res_mine.json()
for i in resp_mine['results']:
auth_data_list.append(i['id'])
return auth_data_list
def get_storage_file_by_id(request):
url = "https://services.humanbrainproject.eu/storage/v1/api/file/7047b77d-10a7-45ee-903a-29fe7a8cc9e5/content/"
headers = {
'Authorization': get_auth_header(request.user.social_auth.get())
}
res = requests.get(url, headers=headers)
if res.status_code != 200:
return False
return res._content
def get_collab_name(self):
import bbp_services.client as bsc
services = bsc.get_services()
headers = {
'Authorization':
get_auth_header(self.request.user.social_auth.get())
}
url = services['collab_service']['prod']['url'] + "collab/{}/".format(
self.object.project)
response = requests.get(url, headers=headers)
collab_name = response.json()["title"]
return collab_name
def get_authorization_header(request):
auth = request.META.get("HTTP_AUTHORIZATION", None)
if auth is None:
try:
auth = get_auth_header(request.user.social_auth.get())
logger.debug("Got authorization from database")
except AttributeError:
pass
# in case of 401 error, need to trap and redirect to login
else:
logger.debug("Got authorization from HTTP header")
return {'Authorization': auth}
def test_auth_header(self, mock_request_response):
social_auth = MagicMock()
social_auth.extra_data = {
'access_token': EXPIRED_TOKEN,
'refresh_token': 'refresh_token',
'token_type': 'Bearer'
}
backend = MagicMock()
backend.refresh_token.return_value = {'access_token': NEW_TOKEN}
social_auth.get_backend_instance.return_value = backend
mock_request_response.return_value.status_code = 200
eq_('Bearer ' + NEW_TOKEN, get_auth_header(social_auth))
def get_storage_navigation_data (request, collab_id):
svc_url = settings.HBP_COLLAB_SERVICE_URL
headers = {'Authorization': get_auth_header(request.user.social_auth.get())}
url = '%scollab/%s/nav/all/' % (svc_url, collab_id)
res = requests.get(url, headers=headers)
if res.status_code != 200:
return False
for i in res.json() :
if i["name"] == "Storage" :
return (i)
return (None)
def _is_collaborator(request, collab_id):
'''check access depending on context'''
svc_url = settings.HBP_COLLAB_SERVICE_URL
headers = {'Authorization': get_auth_header(request.user.social_auth.get())}
url = '%scollab/%s/permissions/' % (svc_url, collab_id)
res = requests.get(url, headers=headers)
if res.status_code != 200:
return False
return res.json().get('UPDATE', False)
def get_storage_navigation_data(request, collab_id):
svc_url = settings.HBP_COLLAB_SERVICE_URL
headers = {
'Authorization': get_auth_header(request.user.social_auth.get())
}
url = '%scollab/%s/nav/all/' % (svc_url, collab_id)
res = requests.get(url, headers=headers)
if res.status_code != 200:
return False
for i in res.json():
if i["name"] == "Storage":
return (i)
return (None)
def _is_collaborator(request, collab_id):
'''check access depending on context'''
svc_url = settings.HBP_COLLAB_SERVICE_URL
headers = {
'Authorization': get_auth_header(request.user.social_auth.get())
}
url = '%scollab/%s/permissions/' % (svc_url, collab_id)
res = requests.get(url, headers=headers)
if res.status_code != 200:
return False
return res.json().get('UPDATE', False)
def get_user_info(request):
"""
:param request: request
:type request: str
:param collab_id: int
:type collab_id: int
:returns: response
:rtype: str
"""
social_auth = request.user.social_auth.get()
url = "https://services.humanbrainproject.eu/oidc/userinfo"
headers = {
'Authorization': get_auth_header(request.user.social_auth.get()),
}
res = requests.post(url, headers=headers)
return res.json()
def get_collab_storage_url(self):
import bbp_services.client as bsc
services = bsc.get_services()
headers = {
'Authorization':
get_auth_header(self.request.user.social_auth.get())
}
url = services['collab_service']['prod'][
'url'] + "collab/{}/nav/all/".format(self.object.project)
response = requests.get(url, headers=headers)
if response.ok:
nav_items = response.json()
for item in nav_items:
if item["app_id"] == "31": # Storage app
return "https://collab.humanbrainproject.eu/#/collab/{}/nav/{}".format(
self.object.project, item["id"])
else:
return ""
def __is_collaborator(request):
'''check access depending on context'''
svc_url = settings.HBP_COLLAB_SERVICE_URL
context = request.GET.get('ctx')
if not context:
return False
url = '%s/collab/context/%s/' % (svc_url, context)
headers = {'Authorization': get_auth_header(request.user.social_auth.get())}
res = requests.get(url, headers=headers)
if res.status_code != 200:
return False
collab_id = res.json()['collab']['id']
url = '%s/collab/%s/permissions/' % (svc_url, collab_id)
res = requests.get(url, headers=headers)
if res.status_code != 200:
return False
return res.json().get('UPDATE', False)
def _is_collaborator_read_permission(request, collab_id):
"""
Check access depending on context
:param request: request
:type request: str
:param collab_id: int
:type collab_id: int
:returns: admins
:rtype: boolean
"""
svc_url = settings.HBP_COLLAB_SERVICE_URL
headers = {
'Authorization': get_auth_header(request.user.social_auth.get())
}
url = '%scollab/%s/permissions/' % (svc_url, collab_id)
res = requests.get(url, headers=headers)
if res.status_code != 200:
return False
return res.json().get('VIEW', False)
def get_authorization_header(request):
auth = request.META.get("HTTP_AUTHORIZATION", None)
if auth is None:
try:
auth = get_auth_header(request.user.social_auth.get())
# logger.debug("Got authorization from database")
except AttributeError:
pass
# in case of 401 error, need to trap and redirect to login
else:
if request.META.get("HTTP_AUTHORIZATION", None).split(" ")[0].lower() == "bearer" :
auth = request.META.get("HTTP_AUTHORIZATION", None)
else :
auth = "Bearer "+request.META.get("HTTP_AUTHORIZATION", None)
# logger.debug("Got authorization from HTTP header")
return {'Authorization': auth}
def overview(request):
# if not in DEBUG mode check whether authentication token is valid
if not settings.DEBUG:
if not 'ctx' in request.session:
# read context
context = request.GET.get('ctx', None)
else:
context = request.session['ctx']
# if not ctx exit the application
if not context:
return render(request, 'efelg/hbp_redirect.html')
# set context
request.session['ctx'] = context
# get headers for requests
headers = {'Authorization': \
get_auth_header(request.user.social_auth.get())}
# build path for getting credentials
my_url = settings.HBP_MY_USER_URL
hbp_collab_service_url = settings.HBP_COLLAB_SERVICE_URL + 'collab/context/'
# request user and collab details
res = requests.get(my_url, headers=headers)
collab_res = requests.get(hbp_collab_service_url + context, \
headers = headers)
if res.status_code != 200 or collab_res.status_code != 200:
manage_auth.Token.renewToken(request)
headers = {'Authorization': \
get_auth_header(request.user.social_auth.get())}
res = requests.get(my_url, headers=headers)
collab_res = requests.get(hbp_collab_service_url + context, \
headers = headers)
if res.status_code != 200 or collab_res.status_code != 200:
return render(request, 'efelg/hbp_redirect.html')
# extract information on user credentials and collab
username = res.json()['username']
userid = res.json()['id']
collab_id = collab_res.json()['collab']['id']
else:
username = '******'
headers = {}
context = 'local'
collab_id = -1
# build data and json dir strings
data_dir = os.path.join(settings.MEDIA_ROOT, \
'efel_data', 'app_data', 'efelg_rawdata')
main_json_dir = os.path.join(settings.MEDIA_ROOT, \
'efel_data', 'eg_json_data')
app_data_dir = os.path.join(settings.MEDIA_ROOT, 'efel_data', 'app_data')
json_dir = os.path.join(main_json_dir, 'traces')
conf_dir = os.path.join(main_json_dir, 'conf_json')
metadata_dir = os.path.join(main_json_dir, 'metadata')
request.session['conf_dir'] = conf_dir
request.session['data_dir'] = data_dir
request.session['json_dir'] = json_dir
request.session['app_data_dir'] = app_data_dir
# create folders for global data and json files if not existing
if not os.path.exists(data_dir):
os.makedirs(data_dir)
if not os.path.exists(data_dir):
os.makedirs(data_dir)
if not os.path.exists(json_dir):
os.makedirs(json_dir)
# save parameters in request.session
request.session["username"] = username
request.session["userid"] = userid
request.session["headers"] = headers
request.session["authorized_data_list"] = []
request.session["current_authorized_files"] = []
# reading parameters from request.session
username = request.session["username"]
# parameters for folder creation
time_info = datetime.datetime.now().strftime('%Y%m%d%H%M%S')
# create global variables in request.session
request.session["time_info"] = time_info
# build local folder paths
res_dir = os.path.join("efel_gui", "results")
r_up_dir = os.path.join("efel_gui", "uploaded")
res_dir = os.path.join(settings.MEDIA_ROOT, \
"efel_data", res_dir)
up_dir = os.path.join(settings.MEDIA_ROOT, \
"efel_data", r_up_dir)
# build local folder complete paths
u_time_f = os.path.join(userid, time_info)
user_res_dir = os.path.join(res_dir, userid)
user_crr_res_dir = os.path.join(res_dir, u_time_f)
u_up_dir = os.path.join(up_dir, userid)
u_crr_res_r_dir = os.path.join(res_dir, userid, time_info, "u_res")
u_crr_res_d_dir = os.path.join(res_dir, userid, time_info, 'u_data')
# build media relative result path
media_rel_crr_user_res = os.path.join('media', 'efel_data', \
res_dir, userid, time_info, 'u_res')
media_abs_crr_user_res = os.path.join(settings.MEDIA_ROOT, 'efel_data', \
res_dir, userid, time_info, 'u_res')
# storage relative path folder
st_rel_user_results_folder = os.path.join(res_dir, \
u_time_f)
st_rel_user_uploaded_folder = os.path.join(r_up_dir, userid)
if not os.path.exists(user_res_dir):
os.makedirs(user_res_dir)
# store paths in request.session
request.session['media_rel_crr_user_res'] = media_rel_crr_user_res
request.session['media_abs_crr_user_res'] = media_abs_crr_user_res
request.session['st_rel_user_results_folder'] = st_rel_user_results_folder
request.session[
'st_rel_user_uploaded_folder'] = st_rel_user_uploaded_folder
request.session['user_crr_res_dir'] = user_crr_res_dir
request.session['user_res_dir'] = user_res_dir
request.session['user_crr_res_dir'] = user_crr_res_dir
request.session['u_crr_res_r_dir'] = u_crr_res_r_dir
request.session['u_crr_res_d_dir'] = u_crr_res_d_dir
request.session['u_up_dir'] = u_up_dir
accesslogger.info(resources.string_for_log('overview', request))
# render to html
return render(request, 'efelg/overview.html')
def get_user(request):
"""
Is used to identify user from HBP token. If user doesn't exist into Database, a new one is created.
"""
user_url = HBP_MY_USER_URL
# Retrieving HBP user's token
headers = {'Authorization': request.META['HTTP_AUTHORIZATION']}
# Getting user's info from HBP_COLLAB
r = requests.get(url=user_url, headers=headers)
if r.status_code != 200:
logger.debug(
"get_user(): User's HBP Token not valid... Try to renew it.")
manage_auth.Token.renewToken(request)
headers = {
'Authorization': get_auth_header(request.user.social_auth.get())
}
r = request.get(url=user_url, headers=headers)
j = json.loads(r.content)
# Try to get user from Database. If user not exists it is created.
try:
logger.debug('get_user(): Getting user with id: ' + j['id'])
user = User.objects.get(id=j['id'])
except User.DoesNotExist:
logger.debug('get_user(): User ' + j['username'] + ' and id: ' +
j['id'] + ' does not exist and it will be create.')
emails = j['emails']
institutions = j['institutions']
institution = ''
for e in emails:
if e['primary']:
email = e['value']
for i in institutions:
if i['primary']:
institution = i['name']
# If user has not set institution, it will be set automatically to 'UNKNOWN' and country to 'IT', otherwise
# the country code is set as the email domain (uppercase) if it is not equal to 'com'
if not institution:
country = 'IT'
elif email.split('.')[-1] != 'com':
country = email.split('.')[-1].upper()
else:
logger.error('get_user(): Set country code for user ' + j['id'] +
'.')
data = {
'id': j['id'],
'username': j['username'],
'email': email,
'institution': institution,
'country': country
}
serializer = UserSerializer(data=data)
if serializer.is_valid():
# if is all right user is saved and it's added to default projects
user = serializer.save()
logger.debug('get_user(): User ' + str(user) +
' was created successfully')
add_default_quota_for_user(user)
else:
logger.debug(
'get_user(): Errors in user creation.\nget_user(): ========= ERROR: =========\nget_user():'
)
print serializer.errors
return serializer.errors
return user
