X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=portal%2Factions.py;h=6d657ed896054a0827706468076f8ea09836d845;hb=56a406a324edea50be41bdd649319491fa391ca4;hp=3f8301355810d0afecddbc6ea806c3f722f14906;hpb=a7e39005063e624c4d12122beb052ff1fa2890cb;p=unfold.git diff --git a/portal/actions.py b/portal/actions.py index 3f830135..6d657ed8 100644 --- a/portal/actions.py +++ b/portal/actions.py @@ -1,29 +1,43 @@ -from django.http import HttpResponse -from manifold.core.query import Query -from manifoldapi.manifoldapi import execute_query,execute_admin_query -from portal.models import PendingUser, PendingSlice, PendingAuthority +from django.http import HttpResponse +from manifold.core.query import Query +from manifoldapi.manifoldapi import execute_query,execute_admin_query +from portal.models import PendingUser, PendingSlice, PendingAuthority, PendingProject, PendingJoin +from unfold.page import Page + import json -from django.contrib.auth.models import User -from django.template.loader import render_to_string -from django.core.mail import EmailMultiAlternatives, send_mail +from django.contrib.auth.models import User +from django.contrib.sites.models import Site +from django.contrib.auth import get_user_model +from django.template.loader import render_to_string +from django.core.mail import EmailMultiAlternatives, send_mail + +from myslice.theme import ThemeView +from myslice.configengine import ConfigEngine -from myslice.theme import ThemeView theme = ThemeView() +import activity.slice + # Thierry: moving this right into the code so # most people can use myslice without having to install sfa # XXX tmp sfa dependency, should be moved to SFA gateway #from sfa.util.xrn import Xrn -# Get the list of authorities - +# Get the list of pis in a given authority def authority_get_pis(request, authority_hrn): - query = Query.get('authority').filter_by('authority_hrn', '==', authority_hrn).select('pi_users') + # CACHE PB with fields + page = Page(request) + metadata = page.get_metadata() + auth_md = metadata.details_by_object('authority') + auth_fields = [column['name'] for column in auth_md['column']] + + # REGISTRY ONLY TO BE REMOVED WITH MANIFOLD-V2 + query = Query.get('myslice:authority').filter_by('authority_hrn', '==', authority_hrn).select(auth_fields) results = execute_admin_query(request, query) - print "authority_get_pis = %s" % results + #print "authority_get_pis = %s" % results # NOTE: temporarily commented. Because results is giving empty list. # Needs more debugging #if not results: @@ -32,6 +46,80 @@ def authority_get_pis(request, authority_hrn): #return result['pi_users'] return results +#check the user is pi or not in the registry +def authority_check_pis(request, user_email): + try: + user_query = Query().get('local:user').filter_by('email', '==', user_email).select('user_id','email','password','config') + user_details = execute_admin_query(request, user_query) + + # getting the authority_hrn + for user_detail in user_details: + user_id = user_detail['user_id'] + if user_detail['config']: + config = json.loads(user_detail['config']) + authority_hrn = config.get('authority','Unknown Authority') + + account_query = Query().get('local:account').filter_by('user_id', '==', user_id).select('user_id','platform_id','auth_type','config') + account_details = execute_admin_query(request, account_query) + + platform_query = Query().get('local:platform').select('platform_id','platform') + platform_details = execute_admin_query(request, platform_query) + + for account_detail in account_details: + for platform_detail in platform_details: + if platform_detail['platform_id'] == account_detail['platform_id']: + if 'myslice' in platform_detail['platform']: + account_config = json.loads(account_detail['config']) + user_hrn = account_config.get('user_hrn','N/A') + + pi_status = False + pis = authority_get_pis (request, authority_hrn) + for pi in pis: + pi_list = pi['pi_users'] + + if user_hrn in pi_list: + pi_status = True + return pi_status + + except Exception,e: + print "Exception in actions.py in authority_check_pis %s" % e + return None + + +def authority_add_pis(request, authority_hrn,user_hrn): + try: + # getting pis of the authority of the user + pis = authority_get_pis (request, authority_hrn) + for pi in pis: + pi_list = pi['pi_users'] + + updated_pi_list = pi_list.append(user_hrn) + query = Query.update('myslice:authority').filter_by('authority_hrn', '==', authority_hrn).set({'pi_users':pi_list}) + results = execute_query(request,query) + newpis = authority_get_pis (request, authority_hrn) + return newpis + except Exception,e: + print "Exception in actions.py in authority_add_pis %s" % e + return None + + +def authority_remove_pis(request, authority_hrn,user_hrn): + try: + # getting pis of the authority of the user + pis = authority_get_pis (request, authority_hrn) + for pi in pis: + pi_list = pi['pi_users'] + + updated_pi_list = pi_list.remove(user_hrn) + query = Query.update('authority').filter_by('authority_hrn', '==', authority_hrn).set({'pi_users':pi_list}) + results = execute_query(request,query) + newpis = authority_get_pis (request, authority_hrn) + return newpis + except Exception,e: + print "Exception in actions.py in authority_remove_pis %s" % e + return None + + def authority_get_pi_emails(request, authority_hrn): pi_users = authority_get_pis(request,authority_hrn) print "pi_users = %s" % pi_users @@ -42,10 +130,12 @@ def authority_get_pi_emails(request, authority_hrn): #default_email = default_email.replace('\n', '') #return default_email # the above doesn't work - return ['support@myslice.info'] + return ['support@onelab.eu'] else: pi_user_hrns = [ hrn for x in pi_users for hrn in x['pi_users'] ] - query = Query.get('user').filter_by('user_hrn', 'included', pi_user_hrns).select('user_email') + + # REGISTRY ONLY TO BE REMOVED WITH MANIFOLD-V2 + query = Query.get('myslice:user').filter_by('user_hrn', 'included', pi_user_hrns).select('user_email') results = execute_admin_query(request, query) return [result['user_email'] for result in results] @@ -71,7 +161,8 @@ def clear_user_creds(request, user_email): if platform_detail['platform_id'] == account_detail['platform_id']: if 'myslice' in platform_detail['platform']: account_config = json.loads(account_detail['config']) - user_cred = account_config.get('delegated_user_credential','N/A') + #user_cred = account_config.get('delegated_user_credential','N/A') + user_cred = account_config.get('user_credential','N/A') if 'N/A' not in user_cred: user_hrn = account_config.get('user_hrn','N/A') user_pub_key = json.dumps(account_config.get('user_public_key','N/A')) @@ -88,35 +179,50 @@ def clear_user_creds(request, user_email): return None def is_pi(wsgi_request, user_hrn, authority_hrn): - # XXX could be done in a single query ! - - # select pi_authorities from user where user_hrn == "ple.upmc.jordan_auge" - query = Query.get('user').filter_by('user_hrn', '==', user_hrn).select('pi_authorities') - results = execute_admin_query(wsgi_request, query) - if not results: - # XXX Warning ? - return False - result = results[0] - user_authority_hrns = result.get('pi_authorities', []) - return authority_hrn in user_authority_hrns + # authorities from user where user_hrn == "ple.upmc.jordan_auge" + print "#### actions.py is_pi authority_hrn = ", authority_hrn + try: + # CACHE PB with fields + page = Page(wsgi_request) + metadata = page.get_metadata() + user_md = metadata.details_by_object('user') + user_fields = [column['name'] for column in user_md['column']] + + # REGISTRY ONLY TO BE REMOVED WITH MANIFOLD-V2 + query = Query().get('myslice:user').select(user_fields).filter_by('user_hrn','==',user_hrn) + #query = Query.get('myslice:user').filter_by('user_hrn', '==', user_hrn).select('pi_authorities') + results = execute_query(wsgi_request, query) + #print "is_pi results = ", results + for user_detail in results: + if authority_hrn in user_detail['pi_authorities']: + return True + except Exception,e: + print "Exception in actions.py in is_pi %s" % e + return False # SFA get record -def sfa_get_user(request, user_hrn, pub): - query_sfa_user = Query.get('user').filter_by('user_hrn', '==', user_hrn) - result_sfa_user = execute_query(request, query_sfa_user) - return result_sfa_user +def sfa_get_user(request, user_hrn, pub=None): + + # REGISTRY ONLY TO BE REMOVED WITH MANIFOLD-V2 + query_sfa_user = Query.get('myslice:user').filter_by('user_hrn', '==', user_hrn) + result_sfa_user = execute_admin_query(request, query_sfa_user) + return result_sfa_user[0] def sfa_update_user(request, user_hrn, user_params): # user_params: keys [public_key] if 'email' in user_params: user_params['user_email'] = user_params['email'] - query = Query.update('user').filter_by('user_hrn', '==', user_hrn).set(user_params).select('user_hrn') - results = execute_query(request,query) + + # REGISTRY ONLY TO BE REMOVED WITH MANIFOLD-V2 + query = Query.update('myslice:user').filter_by('user_hrn', '==', user_hrn).set(user_params).select('user_hrn') + results = execute_admin_query(request,query) return results def sfa_add_authority(request, authority_params): - query = Query.create('authority').set(authority_params).select('authority_hrn') + + # REGISTRY ONLY TO BE REMOVED WITH MANIFOLD-V2 + query = Query.create('myslice:authority').set(authority_params).select('authority_hrn') results = execute_query(request, query) print "sfa_add_auth results=",results if not results: @@ -125,10 +231,14 @@ def sfa_add_authority(request, authority_params): def sfa_add_user_to_slice(request, user_hrn, slice_params): # UPDATE myslice:slice SET researcher=['ple.upmc.jordan_auge','ple.inria.thierry_parmentelat','ple.upmc.loic_baron','ple.upmc.ciro_scognamiglio','ple.upmc.mohammed-yasin_rahman','ple.upmc.azerty'] where slice_hrn=='ple.upmc.myslicedemo' - query_current_users = Query.get('slice').select('user').filter_by('slice_hrn','==',slice_params['hrn']) + + # REGISTRY ONLY TO BE REMOVED WITH MANIFOLD-V2 + query_current_users = Query.get('myslice:slice').select('user').filter_by('slice_hrn','==',slice_params['hrn']) results_current_users = execute_query(request, query_current_users) slice_params['researcher'] = slice_params['researcher'] | results_current_users - query = Query.update('slice').filter_by('user_hrn', '==', user_hrn).set(slice_params).select('slice_hrn') + + # REGISTRY ONLY TO BE REMOVED WITH MANIFOLD-V2 + query = Query.update('myslice:slice').filter_by('user_hrn', '==', user_hrn).set(slice_params).select('slice_hrn') results = execute_query(request, query) # Also possible but not supported yet # UPDATE myslice:user SET slice=['ple.upmc.agent','ple.upmc.myslicedemo','ple.upmc.tophat'] where user_hrn=='ple.upmc.azerty' @@ -195,8 +305,15 @@ def manifold_update_account(request,user_id,account_params): return results #explicitly mention the platform_id -def manifold_delete_account(request, platform_id, user_id, account_params): - query = Query.delete('local:account').filter_by('platform_id', '==', platform_id).filter_by('user_id', '==', user_id).set(account_params).select('user_id') +def manifold_delete_account(request, user_id, platform_id = None): + query = Query.delete('local:account').filter_by('user_id', '==', user_id) + if platform_id is not None: + query.filter_by('platform_id', '==', platform_id) + results = execute_admin_query(request,query) + return results + +def manifold_delete_user(request, user_id): + query = Query.delete('local:user').filter_by('user_id', '==', user_id).select('user_id') results = execute_admin_query(request,query) return results @@ -210,6 +327,35 @@ def manifold_add_platform(request, platform_params): result, = results return result['platform_id'] +def delete_local_user(wsgi_request, user_email): + user_query = Query().get('local:user') \ + .filter_by('email', '==', user_email) \ + .select('user_id','config') + user = execute_admin_query(wsgi_request, user_query) + if len(user) == 0: + return False + #raise Exception, "User not found, check local DB" + else: + user_id = user[0]['user_id'] + user_config = json.loads(user[0]['config']) + authority_hrn = user_config.get('authority', None) + + if is_pi(wsgi_request, '$user_hrn', authority_hrn): + # removing from Django auth_user + UserModel = get_user_model() + UserModel._default_manager.filter(email__iexact = user_email).delete() + + # removing manifold account + manifold_delete_account(wsgi_request, user_id) + + # removing manifold user + manifold_delete_user(wsgi_request, user_id) + else: + return False + #raise Exception, "No sufficient rights on authority = ",authority_hrn + + return True + def make_request_user(user): request = {} @@ -239,6 +385,29 @@ def make_request_slice(slice): request['purpose'] = slice.purpose return request +def make_request_project(project): + request = {} + request['type'] = 'project' + request['id'] = project.id + request['user_hrn'] = project.user_hrn + request['email'] = project.email + request['timestamp'] = project.created + request['authority_hrn'] = project.authority_hrn + request['project_name'] = project.project_name + request['purpose'] = project.purpose + return request + +def make_request_join(join): + request = {} + request['type'] = 'join' + request['id'] = join.id + request['user_hrn'] = join.user_hrn + request['email'] = join.email + request['timestamp'] = join.created + request['authority_hrn'] = join.authority_hrn + request['project_name'] = join.project_name + return request + def make_request_authority(authority): request = {} request['type'] = 'authority' @@ -260,7 +429,8 @@ def make_request_authority(authority): request['timestamp'] = authority.created return request -def make_requests(pending_users, pending_slices, pending_authorities): +def make_requests(pending_users, pending_slices, pending_authorities, pending_projects, pending_joins): + print "$$$$$$$$$$$$$$$ make_request" requests = [] for user in pending_users: requests.append(make_request_user(user)) @@ -268,10 +438,15 @@ def make_requests(pending_users, pending_slices, pending_authorities): requests.append(make_request_slice(slice)) for authority in pending_authorities: requests.append(make_request_authority(authority)) + for project in pending_projects: + requests.append(make_request_project(project)) + for join in pending_joins: + requests.append(make_request_join(join)) return requests def get_request_by_id(ids): - sorted_ids = { 'user': [], 'slice': [], 'authority': [] } + print "$$$$$$$$$$$$$$$$ get_request_by_id" + sorted_ids = { 'user': [], 'slice': [], 'authority': [], 'project': [], 'join': [] } for type__id in ids: type, id = type__id.split('__') sorted_ids[type].append(id) @@ -280,26 +455,53 @@ def get_request_by_id(ids): pending_users = PendingUser.objects.all() pending_slices = PendingSlice.objects.all() pending_authorities = PendingAuthority.objects.all() + pending_projects = PendingProject.objects.all() + pending_joins = PendingJoin.objects.all() else: pending_users = PendingUser.objects.filter(id__in=sorted_ids['user']).all() pending_slices = PendingSlice.objects.filter(id__in=sorted_ids['slice']).all() pending_authorities = PendingAuthority.objects.filter(id__in=sorted_ids['authority']).all() + pending_projects = PendingProject.objects.filter(id__in=sorted_ids['project']).all() + pending_joins = PendingJoin.objects.filter(id__in=sorted_ids['join']).all() - return make_requests(pending_users, pending_slices, pending_authorities) + return make_requests(pending_users, pending_slices, pending_authorities, pending_projects, pending_joins) def get_requests(authority_hrns=None): - print "get_request_by_authority auth_hrns = ", authority_hrns + print "$$$$$$$$$$$$$ get_request_by_authority auth_hrns = ", authority_hrns if not authority_hrns: ## get those pending users who have confirmed their emails pending_users = PendingUser.objects.filter(status__iexact = 'True') pending_slices = PendingSlice.objects.all() pending_authorities = PendingAuthority.objects.all() + pending_projects = PendingProject.objects.all() + pending_joins = PendingJoin.objects.all() else: - pending_users = PendingUser.objects.filter(authority_hrn__in=authority_hrns).all() - pending_slices = PendingSlice.objects.filter(authority_hrn__in=authority_hrns).all() - pending_authorities = PendingAuthority.objects.filter(authority_hrn__in=authority_hrns).all() - - return make_requests(pending_users, pending_slices, pending_authorities) + pending_users = PendingUser.objects + pending_slices = PendingSlice.objects + pending_authorities = PendingAuthority.objects + pending_projects = PendingProject.objects + pending_joins = PendingJoin.objects + from django.db.models import Q + list_user_Q = list() + list_slice_Q = list() + list_auth_Q = list() + list_proj_Q = list() + list_join_Q = list() + for hrn in authority_hrns: + list_user_Q.append(Q(authority_hrn__startswith=hrn, status__iexact = 'True')) + list_slice_Q.append(Q(authority_hrn__startswith=hrn)) + list_auth_Q.append(Q(site_authority__startswith=hrn)) + list_proj_Q.append(Q(authority_hrn__startswith=hrn)) + list_join_Q.append(Q(authority_hrn__startswith=hrn)) + from operator import __or__ as OR + pending_users = pending_users.filter(reduce(OR, list_user_Q)) + pending_slices = pending_slices.filter(reduce(OR, list_slice_Q)) + pending_authorities = pending_authorities.filter(reduce(OR, list_auth_Q)) + pending_projects = pending_projects.filter(reduce(OR, list_proj_Q)) + pending_joins = pending_joins.filter(reduce(OR, list_join_Q)) + #pending_authorities = pending_authorities.all() #filter(reduce(OR, list_Q)) + + return make_requests(pending_users, pending_slices, pending_authorities, pending_projects, pending_joins) # XXX Is it in sync with the form fields ? @@ -349,6 +551,10 @@ def portal_validate_request(wsgi_request, request_ids): request_status['SFA slice'] = {'status': True } PendingSlice.objects.get(id=request['id']).delete() + # Clear user's Credentials + sfa_user = sfa_get_user(wsgi_request, request['user_hrn']) + clear_user_creds(wsgi_request,sfa_user['user_email']) + except Exception, e: request_status['SFA slice'] = {'status': False, 'description': str(e)} @@ -376,19 +582,209 @@ def portal_validate_request(wsgi_request, request_ids): except Exception, e: request_status['SFA authority'] = {'status': False, 'description': str(e)} + elif request['type'] == 'project': + try: + hrn = request['authority_hrn'] + '.' + request['project_name'] + + # Only hrn is required for Manifold Query + sfa_authority_params = { + 'authority_hrn' : hrn + } + sfa_add_authority(wsgi_request, sfa_authority_params) + request_status['SFA project'] = {'status': True } + PendingProject.objects.get(id=request['id']).delete() + + # Add user as a PI of the project + authority_add_pis(wsgi_request, hrn , request['user_hrn']) + + # Clear user's Credentials + #sfa_user = sfa_get_user(wsgi_request, request['user_hrn']) + clear_user_creds(wsgi_request,request['email']) + + except Exception, e: + request_status['SFA project'] = {'status': False, 'description': str(e)} + + elif request['type'] == 'join': + try: + # Add user as a PI of the project + authority_add_pis(wsgi_request, request['authority_hrn'] , request['user_hrn']) + + request_status['SFA join'] = {'status': True } + PendingJoin.objects.get(id=request['id']).delete() + + # Clear user's Credentials + clear_user_creds(wsgi_request,request['email']) + + except Exception, e: + request_status['SFA join'] = {'status': False, 'description': str(e)+' - '+str(request)} + else: + request_status['other'] = {'status': False, 'description': 'unknown type of request'} # XXX Remove from Pendings in database status['%s__%s' % (request['type'], request['id'])] = request_status return status - def validate_action(request, **kwargs): ids = filter(None, kwargs['id'].split('/')) status = portal_validate_request(request, ids) json_answer = json.dumps(status) return HttpResponse (json_answer, mimetype="application/json") + +def reject_action(request, **kwargs): + ids = filter(None, kwargs['id'].split('/')) + status = portal_reject_request(request, ids) + json_answer = json.dumps(status) + return HttpResponse (json_answer, mimetype="application/json") + + +def portal_reject_request(wsgi_request, request_ids): + status = {} + # get the domain url + current_site = Site.objects.get_current() + current_site = current_site.domain + + + if not isinstance(request_ids, list): + request_ids = [request_ids] + + requests = get_request_by_id(request_ids) + for request in requests: + # type, id, timestamp, details, allowed -- MISSING: authority_hrn + # CAREFUL about details + # user : first name, last name, email, password, keypair + # slice : number of nodes, type of nodes, purpose + + request_status = {} + + if request['type'] == 'user': + try: + request_status['SFA user'] = {'status': True } + # getting user email based on id + ## RAW SQL queries on Django DB- https://docs.djangoproject.com/en/dev/topics/db/sql/ + for user in PendingUser.objects.raw('SELECT * FROM portal_pendinguser WHERE id = %s', [request['id']]): + user_email= user.email + first_name = user.first_name + last_name = user.last_name + + ctx = { + 'first_name' : first_name, + 'last_name' : last_name, + 'portal_url' : current_site, + } + try: + theme.template_name = 'user_request_denied.txt' + text_content = render_to_string(theme.template, ctx) + theme.template_name = 'user_request_denied.html' + html_content = render_to_string(theme.template, ctx) + theme.template_name = 'email_default_sender.txt' + sender = render_to_string(theme.template, ctx) + sender = sender.replace('\n', '') + + subject = 'User request denied.' + + msg = EmailMultiAlternatives(subject, text_content, sender, [user_email]) + msg.attach_alternative(html_content, "text/html") + msg.send() + except Exception, e: + print "Failed to send email, please check the mail templates and the SMTP configuration of your server" + + # removing from Django portal_pendinguser + PendingUser.objects.get(id=request['id']).delete() + + delete_local_user(wsgi_request, user_email) + except Exception, e: + request_status['SFA authority'] = {'status': False, 'description': str(e)} + + elif request['type'] == 'slice': + request_status['SFA slice'] = {'status': True } + + # getting user email based on id + ## RAW SQL queries on Django DB- https://docs.djangoproject.com/en/dev/topics/db/sql/ + for user in PendingSlice.objects.raw('SELECT * FROM portal_pendingslice WHERE id = %s', [request['id']]): + user_email= user.type_of_nodes # XXX type_of_nodes field contains the email [shd be renamed in DB] + slice_name = user.slice_name + purpose = user.purpose + url = user.number_of_nodes + + ctx = { + 'slice_name': slice_name, + 'purpose': purpose, + 'url': url, + 'portal_url': current_site, + } + try: + theme.template_name = 'slice_request_denied.txt' + text_content = render_to_string(theme.template, ctx) + theme.template_name = 'slice_request_denied.html' + html_content = render_to_string(theme.template, ctx) + theme.template_name = 'email_default_sender.txt' + sender = render_to_string(theme.template, ctx) + sender = sender.replace('\n', '') + + subject = 'Slice request denied.' + + msg = EmailMultiAlternatives(subject, text_content, sender, [user_email]) + msg.attach_alternative(html_content, "text/html") + msg.send() + except Exception, e: + print "Failed to send email, please check the mail templates and the SMTP configuration of your server" + + PendingSlice.objects.get(id=request['id']).delete() + + elif request['type'] == 'authority': + request_status['SFA authority'] = {'status': True } + + # getting user email based on id + ## RAW SQL queries on Django DB- https://docs.djangoproject.com/en/dev/topics/db/sql/ + for user in PendingAuthority.objects.raw('SELECT * FROM portal_pendingauthority WHERE id = %s', [request['id']]): + user_email= user.address_line1 # XXX address_line1 field contains the email [shd be renamed in DB] + site_name = user.site_name + city = user.address_city + country = user.address_country + short_name = user.site_abbreviated_name + url = user.site_url + + ctx = { + 'site_name': site_name, + 'short_name': short_name, + 'url': url, + 'city': city, + 'country': country, + 'portal_url' : current_site, + } + + try: + theme.template_name = 'authority_request_denied.txt' + text_content = render_to_string(theme.template, ctx) + theme.template_name = 'authority_request_denied.html' + html_content = render_to_string(theme.template, ctx) + theme.template_name = 'email_default_sender.txt' + sender = render_to_string(theme.template, ctx) + sender = sender.replace('\n', '') + subject = 'Authority request denied.' + msg = EmailMultiAlternatives(subject, text_content, sender, [user_email]) + msg.attach_alternative(html_content, "text/html") + msg.send() + except Exception, e: + print "Failed to send email, please check the mail templates and the SMTP configuration of your server" + + PendingAuthority.objects.get(id=request['id']).delete() + + # XXX TMP we should send an email to the user to inform him/her + elif request['type'] == 'project': + request_status['SFA project'] = {'status': True } + PendingProject.objects.get(id=request['id']).delete() + + elif request['type'] == 'join': + request_status['SFA join'] = {'status': True } + PendingJoin.objects.get(id=request['id']).delete() + + status['%s__%s' % (request['type'], request['id'])] = request_status + + return status + # Django and ajax # http://djangosnippets.org/snippets/942/ @@ -415,33 +811,63 @@ def create_slice(wsgi_request, request): # Add User to Slice if we have the user_hrn in pendingslice table user_hrn = request.get('user_hrn', None) user_hrns = list([user_hrn]) if user_hrn else list() - - user_query = Query().get('user').select('user_hrn','user_email').filter_by('user_hrn','==',user_hrn) + + # CACHE PB with fields + page = Page(wsgi_request) + metadata = page.get_metadata() + user_md = metadata.details_by_object('user') + user_fields = [column['name'] for column in user_md['column']] + + # REGISTRY ONLY TO BE REMOVED WITH MANIFOLD-V2 + #user_query = Query().get('myslice:user').select('user_hrn','user_email').filter_by('user_hrn','==',user_hrn) + user_query = Query().get('myslice:user').select(user_fields).filter_by('user_hrn','==',user_hrn) user_details_sfa = execute_admin_query(wsgi_request, user_query) if not user_details_sfa: raise Exception, "User %s doesn't exist, validate user before validating slice" % user_hrn for user in user_details_sfa: user_email = user['user_email'] + # XXX LOIC Quick fix because this is totally inconsistent + if not 'number_of_nodes' in request: + request['number_of_nodes']="" + # XXX We should create a slice with Manifold terminology slice_params = { 'slice_hrn' : hrn, 'slice_urn' : urn, 'slice_type' : request['type'], + 'url' : request['number_of_nodes'], 'users' : user_hrns, 'slice_enabled' : True } # ignored in request: id, timestamp, number_of_nodes, type_of_nodes, purpose - query = Query.create('slice').set(slice_params).select('slice_hrn') + # REGISTRY ONLY TO BE REMOVED WITH MANIFOLD-V2 + query = Query.create('myslice:slice').set(slice_params).select('slice_hrn') results = execute_query(wsgi_request, query) if not results: raise Exception, "Could not create %s. Already exists ?" % slice_params['hrn'] else: clear_user_creds(wsgi_request,user_email) - subject = 'Slice created' - msg = 'A manager of your institution has validated your slice request. You can now add resources to the slice and start experimenting.' - send_mail(subject, msg, 'support@onelab.eu',[user_email], fail_silently=False) + # log user activity + activity.slice.validate(request, { "slice" : hrn }) + try: + theme.template_name = 'slice_request_validated.txt' + text_content = render_to_string(theme.template, request) + theme.template_name = 'slice_request_validated.html' + html_content = render_to_string(theme.template, request) + + theme.template_name = 'email_default_sender.txt' + sender = render_to_string(theme.template, request) + sender = sender.replace('\n', '') + + subject = 'Slice request validated' + + msg = EmailMultiAlternatives(subject, text_content, sender, [user_email]) + msg.attach_alternative(html_content, "text/html") + msg.send() + except Exception, e: + print "Failed to send email, please check the mail templates and the SMTP configuration of your server" return results @@ -454,8 +880,9 @@ def create_pending_slice(wsgi_request, request, email): slice_name = request['slice_name'], user_hrn = request['user_hrn'], authority_hrn = request['authority_hrn'], - number_of_nodes = request['exp_url'], + number_of_nodes = request['url'], # field needs to be renamed purpose = request['purpose'], + type_of_nodes = request['email'] # field needs to be renamed ) s.save() @@ -480,6 +907,57 @@ def create_pending_slice(wsgi_request, request, email): except Exception, e: print "Failed to send email, please check the mail templates and the SMTP configuration of your server" + +def create_pending_project(wsgi_request, request): + """ + """ + + # Insert an entry in the PendingProject table + s = PendingProject( + project_name = request['project_name'], + user_hrn = request['user_hrn'], + email = request['email'], + authority_hrn = request['authority_hrn'], + purpose = request['purpose'], + ) + s.save() + +def create_pending_join(wsgi_request, request): + """ + """ + + # Insert an entry in the PendingJoin table + s = PendingJoin( + user_hrn = request['user_hrn'], + email = request['email'], + project_name = request['project_name'], + authority_hrn = request['authority_hrn'], + ) + s.save() + + +# try: +# # Send an email: the recipients are the PI of the authority +# recipients = authority_get_pi_emails(wsgi_request, request['authority_hrn']) +# +# theme.template_name = 'slice_request_email.txt' +# text_content = render_to_string(theme.template, request) +# +# theme.template_name = 'slice_request_email.html' +# html_content = render_to_string(theme.template, request) +# +# theme.template_name = 'slice_request_email_subject.txt' +# subject = render_to_string(theme.template, request) +# subject = subject.replace('\n', '') +# +# sender = email +# msg = EmailMultiAlternatives(subject, text_content, sender, recipients) +# msg.attach_alternative(html_content, "text/html") +# msg.send() +# except Exception, e: +# print "Failed to send email, please check the mail templates and the SMTP configuration of your server" + + #------------------------------------------------------------------------------- # REQUESTS - Users #------------------------------------------------------------------------------- @@ -526,7 +1004,7 @@ def manifold_add_reference_user_accounts(wsgi_request, request): } manifold_add_account(wsgi_request, manifold_account_params) -def sfa_create_user(wsgi_request, request): +def sfa_create_user(wsgi_request, request, namespace = None, as_admin = False): """ Arguments: wsgi_request (~ WSGIRequest) : @@ -553,18 +1031,79 @@ def sfa_create_user(wsgi_request, request): 'user_enabled' : True } - query = Query.create('user').set(sfa_user_params).select('user_hrn') - results = execute_query(wsgi_request, query) + if namespace is not None: + query = Query.create('%s:user' % namespace).set(sfa_user_params).select('user_hrn') + else: + # REGISTRY ONLY TO BE REMOVED WITH MANIFOLD-V2 + query = Query.create('myslice:user').set(sfa_user_params).select('user_hrn') + + if as_admin: + results = execute_admin_query(wsgi_request, query) + else: + results = execute_query(wsgi_request, query) + if not results: raise Exception, "Could not create %s. Already exists ?" % sfa_user_params['user_hrn'] else: - subject = 'User validated' - msg = 'A manager of your institution has validated your account. You have now full user access to the portal.' - send_mail(subject, msg, 'support@onelab.eu',[request['email']], fail_silently=False) + try: + theme.template_name = 'user_request_validated.txt' + text_content = render_to_string(theme.template, request) + theme.template_name = 'user_request_validated.html' + html_content = render_to_string(theme.template, request) + + theme.template_name = 'email_default_sender.txt' + sender = render_to_string(theme.template, request) + sender = sender.replace('\n', '') + + + subject = 'Account validated' + + msg = EmailMultiAlternatives(subject, text_content, sender, [request['email']]) + msg.attach_alternative(html_content, "text/html") + msg.send() + except Exception, e: + print "Failed to send email, please check the mail templates and the SMTP configuration of your server" + return results -def create_user(wsgi_request, request): - +def iotlab_create_user (wsgi_request, request, namespace = None, as_admin=False): + + import requests + import time + from requests.auth import HTTPBasicAuth + + engine = ConfigEngine() + URL_REST = engine.iotlab_url() + LOGIN_ADMIN = engine.iotlab_admin_user() + PASSWORD_ADMIN = engine.iotlab_admin_password() + + auth = HTTPBasicAuth(LOGIN_ADMIN,PASSWORD_ADMIN) + headers = {'content-type': 'application/json'} + + for user in PendingUser.objects.raw('SELECT * FROM portal_pendinguser WHERE email = %s', [request['email']]): + password= user.password + + + iotlab_user_params = { + "type" : "SA", + #"login" : request['email'], #auto generated by iotlab + "password" : password, + "firstName" : request['first_name'], + "lastName" : request['last_name'], + "email" : request['email'], + "structure" : request['authority_hrn'], + "city" : "N/A", + "country" : "N/A", + "sshPublicKey" : request['public_key'], + "motivations" : "SFA federation", + } + + iotlab_user_params1 = json.dumps(iotlab_user_params) + r=requests.post(url=URL_REST, data=iotlab_user_params1, headers=headers, auth=auth) + print 'Create iotlab user : ', r.status_code, r.text + return r.text + +def create_user(wsgi_request, request, namespace = None, as_admin = False): # XXX This has to be stored centrally USER_STATUS_ENABLED = 2 @@ -572,7 +1111,7 @@ def create_user(wsgi_request, request): # we would have to perform the steps in create_pending_user too # Add the user to the SFA registry - sfa_create_user(wsgi_request, request) + sfa_create_user(wsgi_request, request, namespace, as_admin) # Update Manifold user status manifold_update_user(wsgi_request, request['email'], {'status': USER_STATUS_ENABLED}) @@ -580,6 +1119,10 @@ def create_user(wsgi_request, request): # Add reference accounts for platforms manifold_add_reference_user_accounts(wsgi_request, request) + # Add the user to iotlab portal if theme is set to onelab + if theme.theme == 'onelab': + iotlab_create_user (wsgi_request, request) + def create_pending_user(wsgi_request, request, user_detail): """ """ @@ -607,7 +1150,6 @@ def create_pending_user(wsgi_request, request, user_detail): theme.template_name = 'activate_user_email_subject.txt' subject = render_to_string(theme.template, request) subject = subject.replace('\n', '') - #sender = 'support@myslice.info' theme.template_name = 'email_default_sender.txt' sender = render_to_string(theme.template, request) sender = sender.replace('\n', '')