HTTPROOT=ROOT
DATAROOT=ROOT
-print "HTTPROOT = ",HTTPROOT
-
if not os.path.isdir(ROOT): raise Exception,"Cannot find ROOT %s for unfold"%ROOT
if not os.path.isdir(HTTPROOT): raise Exception,"Cannot find HTTPROOT %s for unfold"%HTTPROOT
class SliceList (SimpleList):
def __init__ (self, **settings):
- SimpleList.__init__(self, key='slice.slice_hrn', classname='slicelist', **settings)
+ SimpleList.__init__(self, key='slices.slice_hrn', classname='slicelist', **settings)
# writing a js plugin for that would be overkill, just use SimpleList
def plugin_classname (self):
},
// hard-wire a separate presentation depending on the key being used....
+ // XXX Hardcoded key
_cell: function (key, value) {
- if (key == 'slice.slice_hrn') {
+ if (key == 'slices.slice_hrn') {
return "<i class='icon-play-circle'></i><a href='/portal/slice/" + value + "'>" + value + "</a>";
} else if (key == 'platform') {
return "<i class='icon-play-circle'></i><a href='/portal/platform/" + value + "'>" + value + "</a>";
from portal.models import PendingUser, PendingSlice, PendingAuthority
import json
+from portal.models import PendingSlice
+from django.template.loader import render_to_string
+from django.core.mail import send_mail
+
# 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
return results
def authority_get_pi_emails(request, authority_hrn):
- #return ['jordan.auge@lip6.fr', 'loic.baron@lip6.fr']
pi_users = authority_get_pis(request,authority_hrn)
if any(d['pi_users'] == None for d in pi_users):
return ['support@myslice.info']
print "mails", [result['email'] for result in results]
return [result['email'] for result in results]
+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
+
# SFA get record
def sfa_get_user(request, user_hrn, pub):
result_sfa_user = execute_query(request, query_sfa_user)
return result_sfa_user
-# SFA add record (user, slice)
-
-def sfa_add_user(request, user_params):
- if 'email' in user_params:
- user_params['user_email'] = user_params['email']
- query = Query.create('user').set(user_params).select('user_hrn')
- results = execute_query(request, query)
- if not results:
- raise Exception, "Could not create %s. Already exists ?" % user_params['hrn']
- return results
-
def sfa_update_user(request, user_hrn, user_params):
# user_params: keys [public_key]
if 'email' in user_params:
results = execute_query(request,query)
return results
-def sfa_add_slice(request, slice_params):
- query = Query.create('slice').set(slice_params).select('slice_hrn')
- results = execute_query(request, query)
- if not results:
- raise Exception, "Could not create %s. Already exists ?" % slice_params['hrn']
- return results
-
def sfa_add_authority(request, authority_params):
query = Query.create('authority').set(authority_params).select('authority_hrn')
results = execute_query(request, query)
# Propose hrn
-def manifold_add_user(request, user_params):
- # user_params: email, password e.g., user_params = {'email':'aa@aa.com','password':'demo'}
+def manifold_add_user(wsgi_request, request):
+ """Add a Manifold user corresponding to a user request.
+
+ Args:
+ wsgi_request: a WSGIRequest instance
+ request (dict): a dictionary containing the user request built from the
+ form.
+
+ Returns:
+ The user_id of the inserted user.
+
+ Raises:
+ ?
+
+ """
+ USER_CONFIG = '{"firstname": "%(first_name)s", "lastname": "%(last_name)s", "authority": "%(authority_hrn)s"}'
+
+ user_params = {
+ 'email' : request['email'],
+ 'password' : request['password'],
+ 'config' : USER_CONFIG % request,
+ 'status' : 1,
+ }
+
query = Query.create('local:user').set(user_params).select('email')
results = execute_admin_query(request, query)
if not results:
raise Exception, "Failed creating manifold user: %s" % user_params['email']
- result, = results
+ result = results[0]
return result['email']
def manifold_update_user(request, email, user_params):
request_status = {}
- print "REQUEST", request
if request['type'] == 'user':
try:
- # XXX tmp user_hrn inside the keypair column of pendiguser table
- hrn = json.loads(request['keypair'])['user_hrn']
- #hrn = "%s.%s" % (request['authority_hrn'], request['login'])
- # XXX tmp sfa dependency
- from sfa.util.xrn import Xrn
- urn = Xrn(hrn, request['type']).get_urn()
- if 'pi' in request:
- auth_pi = request['pi']
- else:
- auth_pi = ''
- sfa_user_params = {
- 'hrn' : hrn,
- 'urn' : urn,
- 'type' : request['type'],
- 'keys' : [json.loads(request['keypair'])['user_public_key']],
- 'first_name' : request['first_name'],
- 'last_name' : request['last_name'],
- 'email' : request['email'],
- #'slices' : None,
- #'researcher': None,
- 'pi' : [auth_pi],
- 'enabled' : True
- }
- # ignored in request: id, timestamp, password
-
- # ADD USER TO SFA Registry
- sfa_add_user(wsgi_request, sfa_user_params)
-
- # USER INFO
- user_query = Query().get('local:user').select('user_id','config','email','status').filter_by('email', '==', request['email'])
- user_details = execute_admin_query(request, user_query)
- #print user_details[0]
-
- # UPDATE USER STATUS = 2
- manifold_user_params = {
- 'status': 2
- }
- manifold_update_user(request, request['email'], manifold_user_params)
-
- # USER MAIN ACCOUNT != reference
- #print 'USER MAIN ACCOUNT != reference'
- list_accounts_query = Query().get('local:account').select('user_id','platform_id','auth_type','config')\
- .filter_by('user_id','==',user_details[0]['user_id'])\
- .filter_by('auth_type','!=','reference')
- list_accounts = execute_admin_query(request, list_accounts_query)
- #print "List accounts = ",list_accounts
- for account in list_accounts:
- main_platform_query = Query().get('local:platform').select('platform_id','platform').filter_by('platform_id','==',account['platform_id'])
- main_platform = execute_admin_query(request, main_platform_query)
-
- # ADD REFERENCE ACCOUNTS ON SFA ENABLED PLATFORMS
- #print 'ADD REFERENCE ACCOUNTS ON SFA ENABLED PLATFORMS'
- platforms_query = Query().get('local:platform').filter_by('disabled', '==', '0').filter_by('gateway_type','==','sfa').select('platform_id','gateway_type')
- platforms = execute_admin_query(request, platforms_query)
- #print "platforms SFA ENABLED = ",platforms
- for platform in platforms:
- #print "add reference to platform ",platform
- manifold_account_params = {
- 'user_id': user_details[0]['user_id'],
- 'platform_id': platform['platform_id'],
- 'auth_type': 'reference',
- 'config': '{"reference_platform": "' + main_platform[0]['platform'] + '"}',
- }
- manifold_add_account(request, manifold_account_params)
-
+ create_user(wsgi_request, request)
request_status['SFA user'] = {'status': True }
except Exception, e:
elif request['type'] == 'slice':
try:
- hrn = "%s.%s" % (request['authority_hrn'], request['slice_name'])
- # XXX tmp sfa dependency
- from sfa.util.xrn import Xrn
- urn = Xrn(hrn, request['type']).get_urn()
-
- # Add User to Slice if we have the user_hrn in pendingslice table
- if 'user_hrn' in request:
- user_hrn = request['user_hrn']
- print "Slice %s will be created for %s" % (hrn,request['user_hrn'])
- else:
- user_hrn=''
- print "Slice %s will be created without users %s" % (hrn)
- sfa_slice_params = {
- 'hrn' : hrn,
- 'urn' : urn,
- 'type' : request['type'],
- #'slices' : None,
- 'researcher' : [user_hrn],
- #'pi' : None,
- 'enabled' : True
- }
- # ignored in request: id, timestamp, number_of_nodes, type_of_nodes, purpose
-
- sfa_add_slice(wsgi_request, sfa_slice_params)
- #sfa_add_user_to_slice(wsgi_request, user_hrn, sfa_slice_params)
+ create_slice(wsgi_request, request)
request_status['SFA slice'] = {'status': True }
except Exception, e:
# Django and ajax
# http://djangosnippets.org/snippets/942/
+
+
+
+#-------------------------------------------------------------------------------
+# REQUESTS - Slices
+#-------------------------------------------------------------------------------
+
+def create_slice(wsgi_request, request):
+ """
+ Arguments:
+ wsgi_request (~ WSGIRequest) :
+ request (dict) : the slice request in our own dict format
+
+ Raises:
+ Exception
+ """
+ hrn = "%s.%s" % (request['authority_hrn'], request['slice_name'])
+ # XXX tmp sfa dependency
+ from sfa.util.xrn import Xrn
+ urn = Xrn(hrn, request['type']).get_urn()
+
+ # 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()
+
+ # XXX We should create a slice with Manifold terminology
+ slice_params = {
+ 'slice_hrn' : hrn,
+ 'slice_urn' : urn,
+ 'slice_type' : request['type'],
+ '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')
+ results = execute_query(wsgi_request, query)
+ if not results:
+ raise Exception, "Could not create %s. Already exists ?" % slice_params['hrn']
+ return results
+
+def create_pending_slice(wgsi_request, request):
+ """
+ """
+
+ # Insert an entry in the PendingSlice table
+ s = PendingSlice(
+ slice_name = request['slice_name'],
+ user_hrn = request['user_hrn'],
+ authority_hrn = request['authority_hrn'],
+ number_of_nodes = request['number_of_nodes'],
+ purpose = request['purpose'],
+ )
+ s.save()
+
+ # Send an email: the recipients are the PI of the authority
+ recipients = authority_get_pi_emails(wsgi_request, authority_hrn)
+ msg = render_to_string('slice-request-email.txt', request)
+ send_mail("Onelab user %(email)s requested a slice" % request, msg, email, recipients)
+
+#-------------------------------------------------------------------------------
+# REQUESTS - Users
+#-------------------------------------------------------------------------------
+
+def manifold_add_reference_user_accounts(wsgi_request, request):
+ """When a new user is created, add reference accounts to the reference platform.
+ """
+ # XXX XXX XXX The rest of this function has to be checked XXX XXX XXX
+
+ # Retrieve user information
+ user_query = Query().get('local:user') \
+ .select('user_id', 'config', 'email', 'status') \
+ .filter_by('email', '==', request['email'])
+ user_details = execute_admin_query(wsgi_request, user_query)
+
+ # USER MAIN ACCOUNT != reference
+ #print 'USER MAIN ACCOUNT != reference'
+ list_accounts_query = Query().get('local:account') \
+ .select('user_id', 'platform_id', 'auth_type', 'config') \
+ .filter_by('user_id', '==', user_details[0]['user_id']) \
+ .filter_by('auth_type', '!=', 'reference')
+ list_accounts = execute_admin_query(wsgi_request, list_accounts_query)
+
+ # XXX main_platform is being erased several times ???
+ for account in list_accounts:
+ main_platform_query = Query().get('local:platform') \
+ .select('platform_id', 'platform') \
+ .filter_by('platform_id', '==', account['platform_id'])
+ main_platform = execute_admin_query(wsgi_request, main_platform_query)
+
+ # Add reference accounts on SFA enabled platforms
+ platforms_query = Query().get('local:platform') \
+ .filter_by('disabled', '==', '0') \
+ .filter_by('gateway_type', '==', 'sfa') \
+ .select('platform_id', 'gateway_type')
+ platforms = execute_admin_query(wsgi_request, platforms_query)
+ for platform in platforms:
+ #print "add reference to platform ",platform
+ manifold_account_params = {
+ 'user_id' : user_details[0]['user_id'],
+ 'platform_id' : platform['platform_id'],
+ 'auth_type' : 'reference',
+ 'config' : '{"reference_platform": "' + main_platform[0]['platform'] + '"}',
+ }
+ manifold_add_account(wsgi_request, manifold_account_params)
+
+def sfa_create_user(wsgi_request, request):
+ """
+ Arguments:
+ wsgi_request (~ WSGIRequest) :
+ request (dict) : the user request in our own dict format
+
+ Raises:
+ Exception
+ """
+ from sfa.util.xrn import Xrn
+
+ auth_pi = request.get('pi', None)
+ auth_pi = list([auth_pi]) if auth_pi else list()
+
+ # We create a slice request with Manifold terminology
+ sfa_user_params = {
+ 'user_hrn' : request['user_hrn'],
+ 'user_email' : request['email'],
+ 'urn' : Xrn(request['user_hrn'], request['type']).get_urn(),
+ 'type' : request['type'],
+ 'keys' : request['public_key'],
+ 'first_name' : request['first_name'],
+ 'last_name' : request['last_name'],
+ #'slices' : None,
+ #'researcher': None,
+ 'pi' : auth_pi,
+ 'enabled' : True
+ }
+
+ query = Query.create('user').set(user_params).select('user_hrn')
+ results = execute_query(wsgi_request, query)
+ if not results:
+ raise Exception, "Could not create %s. Already exists ?" % user_params['user_hrn']
+ return results
+
+def create_user(wsgi_request, request):
+
+ # XXX This has to be stored centrally
+ USER_STATUS_ENABLED = 2
+
+ # NOTE : if we were to create a user directly (just like we create slices,
+ # we would have to perform the steps in create_pending_user too
+
+ # Add the user to the SFA registry
+ sfa_add_user(wsgi_request, request)
+
+ # Update Manifold user status
+ manifold_update_user(wsgi_request, request['email'], {'status': USER_STATUS_ENABLED})
+
+ # Add reference accounts for platforms
+ manifold_add_reference_user_accounts(wsgi_request, request)
+
+def create_pending_user(wgsi_request, request, user_detail):
+ """
+ """
+
+ # Insert an entry in the PendingUser table
+ b = PendingUser(
+ first_name = request['first_name'],
+ last_name = request['last_name'],
+ authority_hrn = request['authority_hrn'],
+ email = request['email'],
+ password = request['password'],
+ keypair = request['account_config'], # XXX REMOVE
+ public_key = request['public_key'], # TODO NEW
+ private_key = request['private_key'], # TODO NEW
+ user_hrn = request['user_hrn'], # TODO NEW
+ pi = '', # XXX Why not None ?
+ )
+ b.save()
+
+ # saves the user to django auth_user table [needed for password reset]
+ user = User.objects.create_user(request['email'], request['email'], request['password'])
+
+ # Creating a manifold user
+ user_id = manifold_add_user(wsgi_request, request)
+
+ # Creating a Manifold account on the MySlice platform
+ # Note the JSON representation of public and private keys already includes quotes
+ account_config = {
+ 'user_hrn' : request['user_hrn'],
+ 'user_public_key' : request['public_key'],
+ }
+ if request['private_key']:
+ account_config['user_private_key'] = request['private_key']
+
+ user_id = user_detail['user_id'] + 1 # the user_id for the newly created user in local:user
+ account_params = {
+ 'platform_id' : 5, # XXX ALERT !!
+ 'user_id' : user_id,
+ 'auth_type' : request['auth_type'],
+ 'config' : json.dumps(account_config),
+ }
+ manifold_add_account(wsgi_request, account_params)
+
+ # Send an email: the recipients are the PI of the authority
+ recipients = authority_get_pi_emails(wsgi_request, authority_hrn)
+ msg = render_to_string('user_request_email.txt', request)
+ send_mail("Onelab New User request for %(email)s submitted" % request, msg, 'support@myslice.info', recipients)
# root_authority = sub_authority[0]
# slice_query = Query().get(root_authority+':user').filter_by('user_hrn', '==', '$user_hrn').select('user_hrn', 'slice.slice_hrn')
# else:
- slice_query = Query().get('user').filter_by('user_hrn', '==', '$user_hrn').select('slice.slice_hrn')
+ slice_query = Query().get('user').filter_by('user_hrn', '==', '$user_hrn').select('slices.slice_hrn')
page.enqueue_query(slice_query)
page.enqueue_query(testbed_query)
last_name = models.TextField()
email = models.EmailField() #validators=[validate_email])
password = models.TextField()
- keypair = models.TextField()
+ user_hrn = models.TextField()
+ public_key = models.TextField()
+ private_key = models.TextField()
authority_hrn = models.TextField()
login = models.TextField()
pi = models.TextField()
def get (self, request):
return self.get_or_post (request, 'GET')
- def get_or_post (self, request, method):
+ def get_or_post(self, wsgi_request, method):
+ """
+ """
errors = []
- # Using cache manifold-tables to get the list of authorities faster
authorities_query = Query.get('authority').select('name', 'authority_hrn')
-
- #onelab_enabled_query = Query.get('local:platform').filter_by('platform', '==', 'ple').filter_by('disabled', '==', 'False')
- #onelab_enabled = not not execute_admin_query(request, onelab_enabled_query)
- #if onelab_enabled:
- if True:
- print "ONELAB ENABLED"
- #authorities_query = Query.get('ple:authority').select('name', 'authority_hrn').filter_by('authority_hrn', 'included', ['ple.inria', 'ple.upmc', 'ple.ibbtple', 'ple.nitos'])
- # Now using Cache
- else:
- print "FIREXP ENABLED"
-
- authorities = execute_admin_query(request, authorities_query)
+ authorities = execute_admin_query(wsgi_request, authorities_query)
if authorities is not None:
authorities = sorted(authorities)
+
# xxx tocheck - if authorities is empty, it's no use anyway
# (users won't be able to validate the form anyway)
- page = Page(request)
+ # Who am I ?
+ user_query = Query().get('local:user').select('user_id','email')
+ user_details = execute_admin_query(wsgi_request, user_query)
+
+ # Page rendering
+ page = Page(wsgi_request)
page.add_js_files ( [ "js/jquery.validate.js", "js/my_account.register.js" ] )
page.add_css_files ( [ "css/onelab.css", "css/registration.css" ] )
page.add_css_files ( [ "http://code.jquery.com/ui/1.10.3/themes/smoothness/jquery-ui.css" ] )
- print 'registration view, method',method
+ if method == 'POST':
+ # The form has been submitted
- user_query = Query().get('local:user').select('user_id','email')
- user_details = execute_admin_query(self.request, user_query)
+ user_request = {
+ 'first_name' : wsgi_request.POST.get('firstname', ''),
+ 'last_name' : wsgi_request.POST.get('lastname', ''),
+ 'authority_hrn' : wsgi_request.POST.get('authority_hrn', ''),
+ 'email' : wsgi_request.POST.get('email', '').lower(),
+ 'password' : wsgi_request.POST.get('password', ''),
+ }
- if method == 'POST':
- # We shall use a form here
-
- #get_email = PendingUser.objects.get(email)
- reg_fname = request.POST.get('firstname', '')
- reg_lname = request.POST.get('lastname', '')
- #reg_aff = request.POST.get('affiliation','')
- reg_auth = request.POST.get('authority_hrn', '')
- #reg_login = request.POST.get('login', '')
- reg_email = request.POST.get('email','').lower()
- #prepare user_hrn
+ # Construct user_hrn from email (XXX Should use common code)
split_email = reg_email.split("@")[0]
split_email = split_email.replace(".", "_")
- user_hrn = reg_auth + '.' + split_email+ str(randint(1,1000000))
+ user_request['user_hrn'] = user_request['authority_hrn'] \
+ + '.' + split_email + str(randint(1,1000000))
+ # Validate input
UserModel = get_user_model()
-
- #POST value validation
- if (re.search(r'^[\w+\s.@+-]+$', reg_fname)==None):
+ if (re.search(r'^[\w+\s.@+-]+$', user_request['first_name']) == None):
errors.append('First Name may contain only letters, numbers, spaces and @/./+/-/_ characters.')
- if (re.search(r'^[\w+\s.@+-]+$', reg_lname) == None):
+ if (re.search(r'^[\w+\s.@+-]+$', user_request['last_name']) == None):
errors.append('Last Name may contain only letters, numbers, spaces and @/./+/-/_ characters.')
# checking in django_db !!
- if PendingUser.objects.filter(email__iexact=reg_email):
+ if PendingUser.objects.filter(email__iexact = user_request['email']):
errors.append('Email is pending for validation. Please provide a new email address.')
- if UserModel._default_manager.filter(email__iexact=reg_email):
+ if UserModel._default_manager.filter(email__iexact = user_request['email']):
errors.append('This email is not usable. Please contact the administrator or try with another email.')
for user_detail in user_details:
- if user_detail['email']==reg_email:
+ if user_detail['email'] == user_request['email']:
errors.append('Email already registered in Manifold. Please provide a new email address.')
-# XXX TODO: Factorize with portal/accountview.py
- if 'generate' in request.POST['question']:
+ # XXX TODO: Factorize with portal/accountview.py
+ if 'generate' in wsgi_request.POST['question']:
+ user_request['auth_type'] = 'managed'
+
+ # XXX Common code, dependency ?
from Crypto.PublicKey import RSA
private = RSA.generate(1024)
- private_key = json.dumps(private.exportKey())
- public = private.publickey()
- public_key = json.dumps(public.exportKey(format='OpenSSH'))
-
-# # Generate public and private keys using SFA Library
-# from sfa.trust.certificate import Keypair
-# k = Keypair(create=True)
-# public_key = k.get_pubkey_string()
-# private_key = k.as_pem()
-# private_key = ''.join(private_key.split())
-# public_key = "ssh-rsa " + public_key
- # Saving to DB
- account_config = '{"user_public_key":'+ public_key + ', "user_private_key":'+ private_key + ', "user_hrn":"'+ user_hrn + '"}'
- auth_type = 'managed'
- #keypair = re.sub("\r", "", keypair)
- #keypair = re.sub("\n", "\\n", keypair)
- #keypair = keypair.rstrip('\r\n')
- #keypair = ''.join(keypair.split())
- #for sending email: removing existing double qoute
- public_key = public_key.replace('"', '');
+
+ # Example: private_key = '-----BEGIN RSA PRIVATE KEY-----\nMIIC...'
+ # Example: public_key = 'ssh-rsa AAAAB3...'
+ user_request['private_key'] = private.exportKey()
+ user_request['public_key'] = private.public_key().exportKey(format='OpenSSH')
+
else:
- up_file = request.FILES['user_public_key']
- file_content = up_file.read()
- file_name = up_file.name
+ user_request['auth_type'] = 'user'
+
+ up_file = wsgi_request.FILES['user_public_key']
+
+ file_content = up_file.read().strip()
+ file_name = up_file.name
file_extension = os.path.splitext(file_name)[1]
- allowed_extension = ['.pub','.txt']
- if file_extension in allowed_extension and re.search(r'ssh-rsa',file_content):
- account_config = '{"user_public_key":"'+ file_content + '", "user_hrn":"'+ user_hrn +'"}'
- account_config = re.sub("\r", "", account_config)
- account_config = re.sub("\n", "\\n",account_config)
- account_config = ''.join(account_config.split())
- auth_type = 'user'
- # for sending email
- public_key = file_content
- public_key = ''.join(public_key.split())
- else:
+
+ ALLOWED_EXTENSIONS = ['.pub','.txt']
+ if file_extension not in ALLOWED_EXTENSIONS or not re.search(r'ssh-rsa',file_content):
errors.append('Please upload a valid RSA public key.')
- #b = PendingUser(first_name=reg_fname, last_name=reg_lname, affiliation=reg_aff,
- # email=reg_email, password=request.POST['password'], keypair=keypair)
- #b.save()
- #saving to django db 'portal_pendinguser' table
- if not errors:
- b = PendingUser(
- first_name = reg_fname,
- last_name = reg_lname,
- #affiliation = reg_aff,
- authority_hrn = reg_auth,
- #login = reg_login,
- email = reg_email,
- password = request.POST['password'],
- keypair = account_config,
- pi = '',
- )
- b.save()
- # saves the user to django auth_user table [needed for password reset]
- user = User.objects.create_user(reg_email, reg_email, request.POST['password'])
- #creating user to manifold local:user
- user_config = '{"firstname":"'+ reg_fname + '", "lastname":"'+ reg_lname + '", "authority":"'+ reg_auth + '"}'
- user_params = {'email': reg_email, 'password': request.POST['password'], 'config': user_config, 'status': 1}
- manifold_add_user(request,user_params)
- #creating local:account in manifold
- user_id = user_detail['user_id']+1 # the user_id for the newly created user in local:user
- account_params = {'platform_id': 5, 'user_id': user_id, 'auth_type': auth_type, 'config': account_config}
- manifold_add_account(request,account_params)
-
- # Send email
- ctx = {
- 'first_name' : reg_fname,
- 'last_name' : reg_lname,
- 'authority_hrn' : reg_auth,
- 'email' : reg_email,
- 'user_hrn' : user_hrn,
- 'public_key' : public_key,
- }
-
- recipients = authority_get_pi_emails(request,reg_auth)
+ user_request['private_key'] = None
+ user_request['public_key'] = file_content
-
- msg = render_to_string('user_request_email.txt', ctx)
- send_mail("Onelab New User request for %s submitted"%reg_email, msg, 'support@myslice.info', recipients)
+ if not errors:
+ create_pending_user(wsgi_request, user_request, user_detail)
self.template_name = 'user_register_complete.html'
- return render(request, self.template, {'theme': self.theme})
+ return render(wsgi_request, self.template, {'theme': self.theme})
+
+
+ # Backlashed \n => \\n but no surrounding " "
+ public_key_formatted = request['public_key'].replace('"', '');
template_env = {
'topmenu_items': topmenu_items_live('Register', page),
'errors': errors,
- 'firstname': request.POST.get('firstname', ''),
- 'lastname': request.POST.get('lastname', ''),
- #'affiliation': request.POST.get('affiliation', ''),
- 'authority_hrn': request.POST.get('authority_hrn', ''),
- 'email': request.POST.get('email', ''),
- 'password': request.POST.get('password', ''),
'authorities': authorities,
'theme': self.theme
}
+ template_env.update(user_request)
template_env.update(page.prelude_env ())
- return render(request, self.template,template_env)
+ return render(wsgi_request, self.template,template_env)
-from django.template.loader import render_to_string
-from django.shortcuts import render
-from django.core.mail import send_mail
+from django.shortcuts import render
-from unfold.page import Page
+from unfold.page import Page
-from manifold.core.query import Query
-from manifoldapi.manifoldapi import execute_admin_query, execute_query
+from manifold.core.query import Query
+from manifoldapi.manifoldapi import execute_admin_query, execute_query
-from portal.models import PendingSlice
-from portal.actions import authority_get_pi_emails
-from portal.forms import SliceRequestForm
-from unfold.loginrequired import LoginRequiredAutoLogoutView
-from ui.topmenu import topmenu_items_live, the_user
+from portal.actions import is_pi, create_slice, create_pending_slice
+from portal.forms import SliceRequestForm
+from unfold.loginrequired import LoginRequiredAutoLogoutView
+from ui.topmenu import topmenu_items_live, the_user
from theme import ThemeView
-import json
+import json, time
class SliceRequestView (LoginRequiredAutoLogoutView, ThemeView):
template_name = 'slicerequest_view.html'
- def __init__ (self):
- self.user_email = ''
- self.errors = []
-
# because we inherit LoginRequiredAutoLogoutView that is implemented by redefining 'dispatch'
# we cannot redefine dispatch here, or we'd lose LoginRequired and AutoLogout behaviours
def post (self, request):
def get (self, request):
return self.get_or_post (request, 'GET')
- def get_or_post (self, request, method):
- # Using cache manifold-tables to get the list of authorities faster
+ def get_or_post (self, wsgi_request, method):
+ """
+ """
+ errors = []
+
+ # Retrieve the list of authorities
authorities_query = Query.get('authority').select('name', 'authority_hrn')
- authorities = execute_admin_query(request, authorities_query)
+ authorities = execute_admin_query(wsgi_request, authorities_query)
if authorities is not None:
authorities = sorted(authorities)
+ # Get user_hrn (XXX Would deserve to be simplified)
user_query = Query().get('local:user').select('email')
- user_email = execute_query(self.request, user_query)
- self.user_email = user_email[0].get('email')
-
-
+ user_emails = execute_query(wsgi_request, user_query)
+ user_email = user_emails[0].get('email')
+ #
account_query = Query().get('local:account').select('user_id','platform_id','auth_type','config')
- account_details = execute_query(self.request, account_query)
-
+ account_details = execute_query(wsgi_request, account_query)
+ #
platform_query = Query().get('local:platform').select('platform_id','platform','gateway_type','disabled')
- platform_details = execute_query(self.request, platform_query)
+ platform_details = execute_query(wsgi_request, platform_query)
user_hrn = None
# getting user_hrn from local:account
for account_detail in account_details:
account_config = json.loads(account_detail['config'])
user_hrn = account_config.get('user_hrn','N/A')
-
- #user_query = Query().get('user').select('user_hrn').filter_by('user_hrn','==','$user_hrn')
- #user_hrn = execute_query(self.request, user_query)
- #self.user_hrn = user_hrn[0].get('user_hrn')
-
-
- page = Page(request)
+ # Page rendering
+ page = Page(wsgi_request)
page.add_css_files ( [ "http://code.jquery.com/ui/1.10.3/themes/smoothness/jquery-ui.css" ] )
if method == 'POST':
- self.errors = []
-
# The form has been submitted
- slice_name = request.POST.get('slice_name', '')
- authority_hrn = request.POST.get('authority_hrn', '')
- number_of_nodes = request.POST.get('number_of_nodes', '')
- purpose = request.POST.get('purpose', '')
- email = self.user_email
- cc_myself = True
+ slice_request = {
+ 'type' : 'slice',
+ 'id' : None,
+ 'user_hrn' : user_hrn,
+ 'timestamp' : time.time(),
+ 'authority_hrn' : wsgi_request.POST.get('authority_hrn', ''),
+ 'slice_name' : wsgi_request.POST.get('slice_name', ''),
+ 'number_of_nodes' : wsgi_request.POST.get('number_of_nodes', ''),
+ 'type_of_nodes' : wsgi_request.POST.get('type_of_nodes', ''),
+ 'purpose' : wsgi_request.POST.get('purpose', ''),
+ }
+ authority_hrn = slice_request['authority_hrn']
if (authority_hrn is None or authority_hrn == ''):
- self.errors.append('Please, select an authority')
+ errors.append('Please, select an authority')
+
# What kind of slice name is valid?
+ slice_name = slice_request['slice_name']
if (slice_name is None or slice_name == ''):
- self.errors.append('Slice Name is mandatory')
+ errors.append('Slice Name is mandatory')
+ purpose = slice_request['purpose']
if (purpose is None or purpose == ''):
- self.errors.append('Purpose is mandatory')
-
- if not self.errors:
- ctx = {
- 'email': email,
- 'slice_name': slice_name,
- 'authority_hrn': authority_hrn,
- 'number_of_nodes': number_of_nodes,
- 'purpose': purpose,
- }
- s = PendingSlice(
- slice_name = slice_name,
- user_hrn = user_hrn,
- authority_hrn = authority_hrn,
- number_of_nodes = number_of_nodes,
- purpose = purpose
- )
- s.save()
+ errors.append('Purpose is mandatory')
- # The recipients are the PI of the authority
- recipients = authority_get_pi_emails(request, authority_hrn)
- msg = render_to_string('slice-request-email.txt', ctx)
- send_mail("Onelab user %s requested a slice"%email , msg, email, recipients)
+ if not errors:
+ if is_pi(wsgi_request, user_hrn, authority_hrn):
+ # PIs can directly create slices in their own authority...
+ create_slice(wsgi_request, slice_request)
+ self.template_name = 'slice-request-done-view.html'
+ else:
+ # Otherwise a wsgi_request is sent to the PI
+ create_pending_slice(wsgi_request, user_email, slice_name, user_hrn, authority_hrn, number_of_nodes, purpose)
+ self.template_name = 'slice-request-ack-view.html'
- self.template_name = 'slice-request-ack-view.html'
-
- return render(request, self.template, {'theme': self.theme}) # Redirect after POST
+ return render(wsgi_request, self.template, {'theme': self.theme}) # Redirect after POST
+ else:
+ slice_request = {}
+
template_env = {
- 'username': request.user.email,
- 'topmenu_items': topmenu_items_live('Request a slice', page),
- 'errors': self.errors,
- 'slice_name': request.POST.get('slice_name', ''),
- 'authority_hrn': request.POST.get('authority_hrn', ''),
- 'number_of_nodes': request.POST.get('number_of_nodes', ''),
- 'purpose': request.POST.get('purpose', ''),
- 'email': self.user_email,
- 'user_hrn': user_hrn,
- 'cc_myself': True,
- 'authorities': authorities,
- 'theme': self.theme
+ 'username': wsgi_request.user.email,
+ 'topmenu_items': topmenu_items_live('Request a slice', page),
+ 'errors': errors,
+ 'email': user_email,
+ 'user_hrn': user_hrn,
+ 'cc_myself': True,
+ 'authorities': authorities,
+ 'theme': self.theme
}
- template_env.update(page.prelude_env ())
- return render(request, self.template, template_env)
+ template_env.update(slice_request)
+ template_env.update(page.prelude_env())
+ return render(wsgi_request, self.template, template_env)
--- /dev/null
+{% extends "layout-unfold1.html" %}
+
+{% block unfold_main %}
+
+ <h1>Slice created !</h1>
+
+As you are a PI of the site, you slice has directly been created.
+
+{% endblock %}
+
git://git.onelab.eu / unfold.git / commitdiff