Example #1
0
def manifold_add_platform(request, platform_params):
    query = Query.create('local:platform').set(platform_params).select(['user', 'platform'])
    results = execute_admin_query(request,query)
    if not results:
        raise Exception, "Failed creating manifold  platform %s for user: %s" % (platform_params['platform'], platform_params['user'])
    result, = results
    return result['platform_id']
Example #2
0
def manifold_add_account(request, account_params):
    query = Query.create('local:account').set(account_params).select(['user', 'platform'])
    results = execute_admin_query(request,query)
    if not results:
        raise Exception, "Failed creating manifold account on platform %s for user: %s" % (account_params['platform'], account_params['user'])
    result, = results
    return result['user_id']
Example #3
0
def manifold_add_user(request, user_params):
    # user_params: email, password e.g., user_params = {'email':'[email protected]','password':'demo'}
    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
    return result['email']
Example #4
0
def manifold_update_user(request, email, user_params):
    # user_params: password, config e.g., 
    query = Query.update('local:user').filter_by('email', '==', email).set(user_params).select('email')
    results = execute_admin_query(request,query)
    # NOTE: results remains empty and goes to Exception. However, it updates the manifold DB.
    # That's why I commented the exception part. -- Yasin 
    #if not results:
    #    raise Exception, "Failed updating manifold user: %s" % user_params['email']
    #result, = results
    return results
def password_reset(request, is_admin_site=False,
                   template_name='password_reset_form.html',
                   email_template_name='password_reset_email.html',
                   subject_template_name='registration/password_reset_subject.txt',
                   password_reset_form=PasswordResetForm,
                   token_generator=default_token_generator,
                   post_reset_redirect=None,
                   from_email=None,
                   current_app=None,
                   extra_context=None):
    if post_reset_redirect is None:
        post_reset_redirect = reverse('portal.django_passresetview.password_reset_done')
    if request.method == "POST":
        form = password_reset_form(request.POST)
        if form.is_valid():

            ### email check in manifold DB ###
            email = form.cleaned_data['email'].lower() # email inserted on the form
            user_query  = Query().get('local:user').select('user_id','email')
            user_details = execute_admin_query(request, user_query)
            flag = 0
            for user_detail in user_details:
                if user_detail['email']==email:
                    flag = 1
                    break
                    
            if flag == 0:
                messages.error(request, 'Sorry, this email is not registered.')
                return render(request, 'password_reset_form.html', {
                    'form': form,
                    })
            ### end of email check in manifold  ### 

            opts = {
                'use_https': request.is_secure(),
                'token_generator': token_generator,
                'from_email': from_email,
                'email_template_name': email_template_name,
                'subject_template_name': subject_template_name,
                'request': request,
            }
            if is_admin_site:
                opts = dict(opts, domain_override=request.get_host())
            form.save(**opts)
            return HttpResponseRedirect(post_reset_redirect)
    else:
        form = password_reset_form()
    context = {
        'form': form,
    }
    if extra_context is not None:
        context.update(extra_context)
    return TemplateResponse(request, template_name, context,
                            current_app=current_app)
    def get_or_post  (self, 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)
        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)
        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

        user_query  = Query().get('local:user').select('user_id','email')
        user_details = execute_admin_query(self.request, user_query)

        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 
            split_email = reg_email.split("@")[0] 
            split_email = split_email.replace(".", "_")
            user_hrn = reg_auth + '.' + split_email+ str(randint(1,1000000))
            
            UserModel = get_user_model()

            #POST value validation  
            if (re.search(r'^[\w+\[email protected]+-]+$', reg_fname)==None):
                errors.append('First Name may contain only letters, numbers, spaces and @/./+/-/_ characters.')
            if (re.search(r'^[\w+\[email protected]+-]+$', reg_lname) == 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):
                errors.append('Email is pending for validation. Please provide a new email address.')
            if UserModel._default_manager.filter(email__iexact=reg_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:
                    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']:
                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('"', '');
            else: 
                up_file = request.FILES['user_public_key']
                file_content =  up_file.read()
                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:
                    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)
                # backup email: if authority_get_pi_emails fails
                recipients.append('[email protected]')
                
                msg = render_to_string('user_request_email.txt', ctx)
                send_mail("Onelab New User request for %s submitted"%reg_email, msg, '[email protected]', recipients)
                return render(request, 'user_register_complete.html') 

        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,
          }
        template_env.update(page.prelude_env ())
        return render(request, 'registration_view.html',template_env)
Example #7
0
    def get_or_post(self, request, method):
        errors = []
        # List authorities already in the Registry in order to avoid duplicates
        # Using cache manifold-tables to get the list of authorities faster
        authorities_query = Query.get("authority").select("name", "authority_hrn")
        authorities = execute_admin_query(request, authorities_query)
        if authorities is not None:
            authorities = sorted(authorities)
        root_authorities = sorted([a for a in authorities if "." not in a["authority_hrn"]])

        page = Page(request)
        page.add_js_files(["js/jquery.validate.js", "js/join.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"])

        if method == "POST":
            # xxx tocheck - if authorities is empty, it's no use anyway
            # (users won't be able to validate the form anyway)

            # List local users in Manifold DB in order ot avoid duplicates
            user_query = Query().get("local:user").select("user_id", "email")
            list_users = execute_admin_query(self.request, user_query)

            reg_root_authority_hrn = request.POST.get("root_authority_hrn", "").lower()

            reg_site_name = request.POST.get("site_name", "")
            reg_site_authority = request.POST.get("site_authority", "").lower()
            reg_site_abbreviated_name = request.POST.get("site_abbreviated_name", "")
            reg_site_url = request.POST.get("site_url", "")
            reg_site_latitude = request.POST.get("site_latitude", "")
            reg_site_longitude = request.POST.get("site_longitude", "")

            reg_fname = request.POST.get("pi_first_name", "")
            reg_lname = request.POST.get("pi_last_name", "")
            reg_auth = reg_root_authority_hrn + "." + reg_site_authority
            reg_email = request.POST.get("pi_email", "").lower()
            reg_phone = request.POST.get("pi_phone", "")
            # prepare user_hrn
            split_email = reg_email.split("@")[0]
            split_email = split_email.replace(".", "_")
            user_hrn = reg_auth + "." + split_email + str(randint(1, 1000000))

            UserModel = get_user_model()

            reg_address_line1 = request.POST.get("address_line1", "")
            reg_address_line2 = request.POST.get("address_line2", "")
            reg_address_line3 = request.POST.get("address_line3", "")
            reg_address_city = request.POST.get("address_city", "")
            reg_address_postalcode = request.POST.get("address_postalcode", "")
            reg_address_state = request.POST.get("address_state", "")
            reg_address_country = request.POST.get("address_country", "")

            # POST value validation
            if re.search(r"^[\w+\[email protected]+-]+$", reg_fname) == None:
                errors.append("First Name may contain only letters, numbers, spaces and @/./+/-/_ characters.")
            if re.search(r"^[\w+\[email protected]+-]+$", reg_lname) == None:
                errors.append("Last Name may contain only letters, numbers, spaces and @/./+/-/_ characters.")
            if re.search(r"^\w+$", reg_site_authority) == None:
                errors.append("Site Authority may contain only letters or numbers.")
            # checking in django_db !!
            if PendingUser.objects.filter(email__iexact=reg_email):
                errors.append("Email is pending for validation. Please provide a new email address.")
            if PendingAuthority.objects.filter(site_authority__iexact=reg_auth):
                errors.append("This site is pending for validation.")
            if PendingAuthority.objects.filter(site_name__iexact=reg_site_name):
                errors.append("This site is pending for validation.")

            if UserModel._default_manager.filter(email__iexact=reg_email):
                errors.append("This email is not usable. Please contact the administrator or try with another email.")
            for user_detail in list_users:
                if user_detail["email"] == reg_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']:
            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"))

            # Saving to DB
            account_config = (
                '{"user_public_key":'
                + public_key
                + ', "user_private_key":'
                + private_key
                + ', "user_hrn":"'
                + user_hrn
                + '"}'
            )
            auth_type = "managed"
            public_key = public_key.replace('"', "")

            if not errors:
                reg_password = request.POST["pi_password"]
                a = PendingAuthority(
                    site_name=reg_site_name,
                    site_authority=reg_root_authority_hrn + "." + reg_site_authority,
                    site_abbreviated_name=reg_site_abbreviated_name,
                    site_url=reg_site_url,
                    site_latitude=reg_site_latitude,
                    site_longitude=reg_site_longitude,
                    address_line1=reg_address_line1,
                    address_line2=reg_address_line2,
                    address_line3=reg_address_line3,
                    address_city=reg_address_city,
                    address_postalcode=reg_address_postalcode,
                    address_state=reg_address_state,
                    address_country=reg_address_country,
                    authority_hrn=reg_root_authority_hrn,
                )
                a.save()

                reg_password = request.POST["pi_password"]
                b = PendingUser(
                    first_name=reg_fname,
                    last_name=reg_lname,
                    authority_hrn=reg_auth,
                    email=reg_email,
                    password=reg_password,
                    keypair=account_config,
                    pi=reg_auth,
                )
                b.save()

                # saves the user to django auth_user table [needed for password reset]
                user = User.objects.create_user(reg_email, reg_email, reg_password)

                # creating user to manifold local:user
                user_config = (
                    '{"firstname":"' + reg_fname + '", "lastname":"' + reg_lname + '", "authority":"' + reg_auth + '"}'
                )
                user_params = {"email": reg_email, "password": reg_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)

                # We don't need to send this email to user.
                # it's for the PI only
                # if ctx['cc_myself']:
                #    recipients.append(ctx['email'])

                msg = render_to_string("user_request_email.txt", ctx)
                send_mail(
                    "Onelab New Authority request for %s submitted" % reg_email, msg, "[email protected]", recipients
                )
                return render(request, "user_register_complete.html")

        template_env = {
            "topmenu_items": topmenu_items_live("join", page),
            "errors": errors,
            "pi_first_name": request.POST.get("pi_first_name", ""),
            "pi_last_name": request.POST.get("pi_last_name", ""),
            "pi_email": request.POST.get("pi_email", ""),
            "pi_phone": request.POST.get("pi_phone", ""),
            "pi_password": request.POST.get("pi_password", ""),
            "site_name": request.POST.get("site_name", ""),
            "site_authority": request.POST.get("site_authority", "").lower(),
            "site_abbreviated_name": request.POST.get("site_abbreviated_name", ""),
            "site_url": request.POST.get("site_url", ""),
            "site_latitude": request.POST.get("site_latitude", ""),
            "site_longitude": request.POST.get("site_longitude", ""),
            "address_line1": request.POST.get("address_line1", ""),
            "address_line2": request.POST.get("address_line2", ""),
            "address_line3": request.POST.get("address_line3", ""),
            "address_city": request.POST.get("address_city", ""),
            "address_postalcode": request.POST.get("address_postalcode", ""),
            "address_state": request.POST.get("address_state", ""),
            "address_country": request.POST.get("address_country", ""),
            "root_authority_hrn": request.POST.get("root_authority_hrn", "").lower(),
            "root_authorities": root_authorities,
            "authorities": authorities,
        }
        template_env.update(page.prelude_env())
        return render(request, "join_view.html", template_env)
    def get_context_data(self, **kwargs):

        page = Page(self.request)
        page.add_js_files  ( [ "js/jquery.validate.js", "js/my_account.register.js", "js/my_account.edit_profile.js" ] )
        page.add_css_files ( [ "css/onelab.css", "css/account_view.css","css/plugin.css" ] )

        for key, value in kwargs.iteritems():
            #print "%s = %s" % (key, value)
            if key == "email":
                selected_email=value
    
        user_query  = Query().get('local:user').filter_by('email', '==', selected_email).select('user_id','config','email','status')
        user_details = execute_admin_query(self.request, user_query)
        
        # not always found in user_details...
        config={}
        for user_detail in user_details:
            user_id = user_detail['user_id']
            user_email = user_detail['email'] 
            # different significations of user_status
            if user_detail['status'] == 0: 
                user_status = 'Disabled'
            elif user_detail['status'] == 1:
                user_status = 'Validation Pending'
            elif user_detail['status'] == 2:
                user_status = 'Enabled'
            else:
                user_status = 'N/A'
            #email = user_detail['email']
            if user_detail['config']:
                config = json.loads(user_detail['config'])

        platform_query  = Query().get('local:platform').select('platform_id','platform','gateway_type','disabled')
        account_query  = Query().get('local:account').filter_by('user_id', '==', user_id).select('user_id','platform_id','auth_type','config')
        platform_details = execute_query(self.request, platform_query)
        account_details = execute_admin_query(self.request, account_query)
       
        # initial assignment needed for users having account.config = {} 
        platform_name = ''
        account_type = ''
        account_usr_hrn = ''
        account_pub_key = ''
        account_priv_key = ''
        account_reference = ''
        my_users = ''
        my_slices = ''
        my_auths = ''
        ref_acc_list = ''
        principal_acc_list = ''
        user_status_list = []
        platform_name_list = []
        platform_name_secondary_list = []
        platform_access_list = []
        platform_no_access_list = []
        total_platform_list = []
        account_type_list = []
        account_type_secondary_list = []
        account_reference_list = []
        delegation_type_list = []
        user_cred_exp_list = []
        slice_list = []
        auth_list = []
        slice_cred_exp_list = []
        auth_cred_exp_list = []
        usr_hrn_list = []
        pub_key_list = []
          
        for platform_detail in platform_details:
            if 'sfa' in platform_detail['gateway_type']:
                total_platform = platform_detail['platform']
                total_platform_list.append(total_platform)
                
            for account_detail in account_details:
                if platform_detail['platform_id'] == account_detail['platform_id']:
                    platform_name = platform_detail['platform']
                    account_config = json.loads(account_detail['config'])
                    account_usr_hrn = account_config.get('user_hrn','N/A')
                    account_pub_key = account_config.get('user_public_key','N/A')
                    account_reference = account_config.get ('reference_platform','N/A')
                    # credentials of myslice platform
                    if 'myslice' in platform_detail['platform']:
                        acc_user_cred = account_config.get('delegated_user_credential','N/A')
                        acc_slice_cred = account_config.get('delegated_slice_credentials','N/A')
                        acc_auth_cred = account_config.get('delegated_authority_credentials','N/A')

                        if 'N/A' not in acc_user_cred:
                            exp_date = re.search('<expires>(.*)</expires>', acc_user_cred)
                            if exp_date:
                                user_exp_date = exp_date.group(1)
                                user_cred_exp_list.append(user_exp_date)

                            my_users = [{'cred_exp': t[0]}
                                for t in zip(user_cred_exp_list)]
                       

                        if 'N/A' not in acc_slice_cred:
                            for key, value in acc_slice_cred.iteritems():
                                slice_list.append(key)
                                # get cred_exp date
                                exp_date = re.search('<expires>(.*)</expires>', value)
                                if exp_date:
                                    exp_date = exp_date.group(1)
                                    slice_cred_exp_list.append(exp_date)

                            my_slices = [{'slice_name': t[0], 'cred_exp': t[1]}
                                for t in zip(slice_list, slice_cred_exp_list)]

                        if 'N/A' not in acc_auth_cred:
                            for key, value in acc_auth_cred.iteritems():
                                auth_list.append(key)
                                #get cred_exp date
                                exp_date = re.search('<expires>(.*)</expires>', value)
                                if exp_date:
                                    exp_date = exp_date.group(1)
                                    auth_cred_exp_list.append(exp_date)

                            my_auths = [{'auth_name': t[0], 'cred_exp': t[1]}
                                for t in zip(auth_list, auth_cred_exp_list)]


                    # for reference accounts
                    if 'reference' in account_detail['auth_type']:
                        account_type = 'Reference'
                        delegation = 'N/A'
                        platform_name_secondary_list.append(platform_name)
                        account_type_secondary_list.append(account_type)
                        account_reference_list.append(account_reference)
                        ref_acc_list = [{'platform_name': t[0], 'account_type': t[1], 'account_reference': t[2]} 
                            for t in zip(platform_name_secondary_list, account_type_secondary_list, account_reference_list)]
                       
                    elif 'managed' in account_detail['auth_type']:
                        account_type = 'Principal'
                        delegation = 'Automatic'
                    else:
                        account_type = 'Principal'
                        delegation = 'Manual'
                    # for principal (auth_type=user/managed) accounts
                    if 'reference' not in account_detail['auth_type']:
                        platform_name_list.append(platform_name)
                        account_type_list.append(account_type)
                        delegation_type_list.append(delegation)
                        usr_hrn_list.append(account_usr_hrn)
                        pub_key_list.append(account_pub_key)
                        user_status_list.append(user_status)
                        # combining 5 lists into 1 [to render in the template] 
                        principal_acc_list = [{'platform_name': t[0], 'account_type': t[1], 'delegation_type': t[2], 'usr_hrn':t[3], 'usr_pubkey':t[4], 'user_status':t[5],} 
                            for t in zip(platform_name_list, account_type_list, delegation_type_list, usr_hrn_list, pub_key_list, user_status_list)]
                    # to hide private key row if it doesn't exist    
                    if 'myslice' in platform_detail['platform']:
                        account_config = json.loads(account_detail['config'])
                        account_priv_key = account_config.get('user_private_key','N/A')
                    if 'sfa' in platform_detail['gateway_type']:
                        platform_access = platform_detail['platform']
                        platform_access_list.append(platform_access)
       
        # Removing the platform which already has access
        for platform in platform_access_list:
            total_platform_list.remove(platform)
        # we could use zip. this one is used if columns have unequal rows 
        platform_list = [{'platform_no_access': t[0]}
            for t in itertools.izip_longest(total_platform_list)]

        context = super(UserView, self).get_context_data(**kwargs)
        context['principal_acc'] = principal_acc_list
        context['ref_acc'] = ref_acc_list
        context['platform_list'] = platform_list
        context['my_users'] = my_users
        context['my_slices'] = my_slices
        context['my_auths'] = my_auths
        context['user_status'] = user_status
        context['user_email']   = user_email
        context['firstname'] = config.get('firstname',"?")
        context['lastname'] = config.get('lastname',"?")
        context['fullname'] = context['firstname'] +' '+ context['lastname']
        context['authority'] = config.get('authority',"Unknown Authority")
        context['user_private_key'] = account_priv_key
        
        # XXX This is repeated in all pages
        # more general variables expected in the template
        context['title'] = 'Platforms connected to MySlice'
        # the menu items on the top
        context['topmenu_items'] = topmenu_items_live('My Account', page)
        # so we can sho who is logged
        context['username'] = the_user(self.request)
#        context ['firstname'] = config['firstname']
        prelude_env = page.prelude_env()
        context.update(prelude_env)
        return context
def user_process(request, **kwargs):
        
    for key, value in kwargs.iteritems():
        if key == "email":
            selected_email=value

    redirect_url = "/portal/user/"+selected_email
    
    user_query  = Query().get('local:user').filter_by('email', '==', selected_email).select('user_id','email','password','config')
    user_details = execute_admin_query(request, user_query)

    # getting the user_id from the session
    for user_detail in user_details:
        user_id = user_detail['user_id']
        user_email = user_detail['email']

    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:
            # Add reference account to the platforms
            if 'add_'+platform_detail['platform'] in request.POST:
                platform_id = platform_detail['platform_id']
                user_params = {'platform_id': platform_id, 'user_id': user_id, 'auth_type': "reference", 'config': '{"reference_platform": "myslice"}'}
                manifold_add_account(request, user_params)
                messages.info(request, 'Reference Account is added to the selected platform successfully!')
                return HttpResponseRedirect(redirect_url)

            # Delete reference account from the platforms
            if 'delete_'+platform_detail['platform'] in request.POST:
                platform_id = platform_detail['platform_id']
                user_params = {'user_id':user_id}
                manifold_delete_account(request, platform_id, user_id, user_params)
                messages.info(request, 'Refeence Account is removed from the selected platform')
                return HttpResponseRedirect(redirect_url)

            if platform_detail['platform_id'] == account_detail['platform_id']:
                if 'myslice' in platform_detail['platform']:
                    account_config = json.loads(account_detail['config'])
                    acc_slice_cred = account_config.get('delegated_slice_credentials','N/A')
                    acc_auth_cred = account_config.get('delegated_authority_credentials','N/A')
                

                    
    
    # adding the slices and corresponding credentials to list
    if 'N/A' not in acc_slice_cred:
        slice_list = []
        slice_cred = [] 
        for key, value in acc_slice_cred.iteritems():
            slice_list.append(key)       
            slice_cred.append(value)
        # special case: download each slice credentials separately 
        for i in range(0, len(slice_list)):
            if 'dl_'+slice_list[i] in request.POST:
                slice_detail = "Slice name: " + slice_list[i] +"\nSlice Credentials: \n"+ slice_cred[i]
                response = HttpResponse(slice_detail, content_type='text/plain')
                response['Content-Disposition'] = 'attachment; filename="slice_credential.txt"'
                return response

    # adding the authority and corresponding credentials to list
    if 'N/A' not in acc_auth_cred:
        auth_list = []
        auth_cred = [] 
        for key, value in acc_auth_cred.iteritems():
            auth_list.append(key)       
            auth_cred.append(value)
        # special case: download each slice credentials separately
        for i in range(0, len(auth_list)):
            if 'dl_'+auth_list[i] in request.POST:
                auth_detail = "Authority: " + auth_list[i] +"\nAuthority Credentials: \n"+ auth_cred[i]
                response = HttpResponse(auth_detail, content_type='text/plain')
                response['Content-Disposition'] = 'attachment; filename="auth_credential.txt"'
                return response


             
    if 'submit_name' in request.POST:
        edited_first_name =  request.POST['fname']
        edited_last_name =  request.POST['lname']
        
        config={}
        for user_config in user_details:
            if user_config['config']:
                config = json.loads(user_config['config'])
                config['firstname'] = edited_first_name
                config['lastname'] = edited_last_name
                config['authority'] = config.get('authority','Unknown Authority')
                updated_config = json.dumps(config)
                user_params = {'config': updated_config}
            else: # it's needed if the config is empty 
                user_config['config']= '{"firstname":"' + edited_first_name + '", "lastname":"'+ edited_last_name + '", "authority": "Unknown Authority"}'
                user_params = {'config': user_config['config']} 
        # updating config local:user in manifold       
        manifold_update_user(request, user_email, user_params)
        # this will be depricated, we will show the success msg in same page
        # Redirect to same page with success message
        messages.success(request, 'Sucess: First Name and Last Name Updated.')
        return HttpResponseRedirect(redirect_url)       
    
    elif 'submit_auth' in request.POST:
        edited_auth = request.POST['authority']
        
        config={}
        for user_config in user_details:
            if user_config['config']:
                config = json.loads(user_config['config'])
                config['firstname'] = config.get('firstname', 'N/A')
                config['lastname'] = config.get('lastname','N/A')
                config['authority'] = edited_auth
                updated_config = json.dumps(config)
                user_params = {'config': updated_config}
            else: # it's needed if the config is empty 
                user_config['config']= '{"firstname": "N/A", "lastname":"N/A", "authority":"' + edited_auth + '"}'
                user_params = {'config': user_config['config']}
        # updating config local:user in manifold       
        manifold_update_user(request, user_email, user_params)
        # this will be depricated, we will show the success msg in same page
        # Redirect to same page with success message
        messages.success(request, 'Sucess: Authority Updated.')
        return HttpResponseRedirect(redirect_url)

# XXX TODO: Factorize with portal/registrationview.py

    elif 'generate' in request.POST:
        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']:
                        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'))
                        # updating manifold local:account table
                        account_config = json.loads(account_detail['config'])
                        # preserving user_hrn
                        user_hrn = account_config.get('user_hrn','N/A')
                        keypair = '{"user_public_key":'+ public_key + ', "user_private_key":'+ private_key + ', "user_hrn":"'+ user_hrn + '"}'
                        updated_config = json.dumps(account_config) 
                        # updating manifold
                        user_params = { 'config': keypair, 'auth_type':'managed'}
                        manifold_update_account(request, user_id, user_params)
                        # updating sfa
                        #public_key = public_key.replace('"', '');
                        #user_pub_key = {'keys': public_key}
                        #sfa_update_user(request, user_hrn, user_pub_key)
                        messages.success(request, 'Sucess: New Keypair Generated! Delegation of your credentials will be automatic.')
                        return HttpResponseRedirect(redirect_url)
        else:
            messages.error(request, 'Account error: You need an account in myslice platform to perform this action')
            return HttpResponseRedirect(redirect_url)
                       
    elif 'upload_key' in request.POST:
        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']:
                        up_file = request.FILES['pubkey']
                        file_content =  up_file.read()
                        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 = json.loads(account_detail['config'])
                            # preserving user_hrn
                            user_hrn = account_config.get('user_hrn','N/A')
                            file_content = '{"user_public_key":"'+ file_content + '", "user_hrn":"'+ user_hrn +'"}'
                            #file_content = re.sub("\r", "", file_content)
                            #file_content = re.sub("\n", "\\n",file_content)
                            file_content = ''.join(file_content.split())
                            #update manifold local:account table
                            user_params = { 'config': file_content, 'auth_type':'user'}
                            manifold_update_account(request,user_id,user_params)
                            # updating sfa
                            #user_pub_key = {'keys': file_content}
                            #sfa_update_user(request, user_hrn, user_pub_key)
                            messages.success(request, 'Publickey uploaded! Please delegate your credentials using SFA: http://trac.myslice.info/wiki/DelegatingCredentials')
                            return HttpResponseRedirect(redirect_url)
                        else:
                            messages.error(request, 'RSA key error: Please upload a valid RSA public key [.txt or .pub].')
                            return HttpResponseRedirect(redirect_url)
        else:
            messages.error(request, 'Account error: You need an account in myslice platform to perform this action')
            return HttpResponseRedirect("/portal/account/")

    elif 'dl_pubkey' in request.POST:
        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'])
                        public_key = account_config['user_public_key'] 
                        response = HttpResponse(public_key, content_type='text/plain')
                        response['Content-Disposition'] = 'attachment; filename="pubkey.txt"'
                        return response
                        break
        else:
            messages.error(request, 'Account error: You need an account in myslice platform to perform this action')
            return HttpResponseRedirect(redirect_url)
               
    elif 'dl_pkey' in request.POST:
        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'])
                        if 'user_private_key' in account_config:
                            private_key = account_config['user_private_key']
                            response = HttpResponse(private_key, content_type='text/plain')
                            response['Content-Disposition'] = 'attachment; filename="privkey.txt"'
                            return response
                        else:
                            messages.error(request, 'Download error: Private key is not stored in the server')
                            return HttpResponseRedirect(redirect_url)

        else:
            messages.error(request, 'Account error: You need an account in myslice platform to perform this action')
            return HttpResponseRedirect("/portal/account/")
    
#    elif 'delete' in request.POST:
#        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'])
#                        if 'user_private_key' in account_config:
#                            for key in account_config.keys():
#                                if key == 'user_private_key':    
#                                    del account_config[key]
#                                
#                            updated_config = json.dumps(account_config)
#                            user_params = { 'config': updated_config, 'auth_type':'user'}
#                            manifold_update_account(request,user_params)
#                            messages.success(request, 'Private Key deleted. You need to delegate credentials manually once it expires.')
#                            messages.success(request, 'Once your credentials expire, Please delegate manually using SFA: http://trac.myslice.info/wiki/DelegatingCredentials')
#                            return HttpResponseRedirect("/portal/account/")
#                        else:
#                            messages.error(request, 'Delete error: Private key is not stored in the server')
#                            return HttpResponseRedirect(redirect_url)
#                           
#        else:
#            messages.error(request, 'Account error: You need an account in myslice platform to perform this action')    
#            return HttpResponseRedirect(redirect_url)

    #clear all creds
    elif 'clear_cred' in request.POST:
        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_cred = account_config.get('delegated_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'))
                            user_priv_key = json.dumps(account_config.get('user_private_key','N/A'))
                            updated_config = '{"user_public_key":'+ user_pub_key + ', "user_private_key":'+ user_priv_key + ', "user_hrn":"'+ user_hrn + '"}'
                            user_params = { 'config': updated_config}
                            manifold_update_account(request, user_id,user_params)
                            messages.success(request, 'All Credentials cleared')
                            return HttpResponseRedirect("/portal/account/")
                        else:
                            messages.error(request, 'Delete error: Credentials are not stored in the server')
                            return HttpResponseRedirect(redirect_url)
        else:
            messages.error(request, 'Account error: You need an account in myslice platform to perform this action')
            return HttpResponseRedirect(redirect_url)


    # Download delegated_user_cred
    elif 'dl_user_cred' in request.POST:
        if 'delegated_user_credential' in account_config:
            user_cred = account_config['delegated_user_credential']
            response = HttpResponse(user_cred, content_type='text/plain')
            response['Content-Disposition'] = 'attachment; filename="user_cred.txt"'
            return response
        else:
            messages.error(request, 'Download error: User credential  is not stored in the server')
            return HttpResponseRedirect(redirect_url)
        
    else:
        messages.info(request, 'Under Construction. Please try again later!')
        return HttpResponseRedirect(redirect_url)
Example #10
0
def portal_validate_request(wsgi_request, request_ids):
    status = {}

    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 = {}

        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)
        
                request_status['SFA user'] = {'status': True }

            except Exception, e:
                 request_status['SFA user'] = {'status': False, 'description': str(e)}
                       
#            user_params = {'status':2}
#            manifold_update_user(request, request['email'], user_params)

            # MANIFOLD user should be added beforehand, during registration
            #try:
            #    manifold_user_params = { key: request[key] for key in MANIFOLD_USER_KEYS }
            #    # XXX # manifold_add_user(manifold_user_params)
            #    request_status['MySlice user'] = {'status': True }
            #except Exception, e:
            #    request_status['MySlice user'] = {'status': False, 'description': str(e)}

            # XXX
            #manifold_account_params = { key: request[key] for key in MANIFOLD_ACCOUNT_KEYS }
            #manifold_add_account(manifold_account_params)
            #request_status['MySlice testbed accounts'] = {'status': False }

        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)
                request_status['SFA slice'] = {'status': True }

            except Exception, e:
                request_status['SFA slice'] = {'status': False, 'description': str(e)}
Example #11
0
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')
    results = execute_admin_query(request,query)
    return results
Example #12
0
def manifold_update_account(request,user_id,account_params):
    # account_params: config
    query = Query.update('local:account').filter_by('platform', '==', 'myslice').filter_by('user_id', '==', user_id).set(account_params).select('user_id')
    results = execute_admin_query(request,query)
    return results
    def get_or_post  (self, request, method):
        # Using cache manifold-tables to get the list of authorities faster
        authorities_query = Query.get('authority').select('name', 'authority_hrn')
        authorities = execute_admin_query(request, authorities_query)
        if authorities is not None:
            authorities = sorted(authorities)

        user_query  = Query().get('local:user').select('email')
        user_email = execute_query(self.request, user_query)
        self.user_email = user_email[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)

        platform_query  = Query().get('local:platform').select('platform_id','platform','gateway_type','disabled')
        platform_details = execute_query(self.request, platform_query)

        # getting user_hrn from local:account
        for account_detail in account_details:
            for platform_detail in platform_details:
                if platform_detail['platform_id'] == account_detail['platform_id']:
                    # taking user_hrn only from myslice account
                    # NOTE: we should later handle accounts filter_by auth_type= managed OR user
                    if 'myslice' in platform_detail['platform']:
                        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.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
            #user_hrn = user_hrn
            cc_myself = True
            
            if (authority_hrn is None or authority_hrn == ''):
                self.errors.append('Please, select an authority')
            # What kind of slice name is valid?
            if (slice_name is None or slice_name == ''):
                self.errors.append('Slice Name is mandatory')
    
            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()
    
                # The recipients are the PI of the authority
                recipients = authority_get_pi_emails(request, authority_hrn)
    
                #if cc_myself:
                recipients.append('[email protected]')
                msg = render_to_string('slice-request-email.txt', ctx)
                #print "email, msg, email, recipients", email , msg, email, recipients 
                send_mail("Onelab user %s requested a slice"%email , msg, email, recipients)
    
                return render(request,'slice-request-ack-view.html') # Redirect after POST
     
        template_env = {
          '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,
        }
        template_env.update(page.prelude_env ())
        return render(request, 'slicerequest_view.html',template_env)
Example #14
0
    def get_context_data(self, **kwargs):
        page = Page(self.request)
        page.add_js_files  ( [ "js/common.functions.js" ] )
        #platform_query  = Query().get('local:platform').filter_by('disabled', '==', '0').select('platform','platform_longname','gateway_type')
        #platform_query  = Query().get('local:platform').select('platform','platform_longname','gateway_type')
        email_list = []
        status_list = []
        authority_list = []
        config={}

        user_query  = Query().get('local:user').select('email','status','config')
        user_details = execute_admin_query(self.request, user_query)

        for user in user_details:
            # get email
            email_list.append(user['email'])
            # get status
            if user['status'] == 0:
                user_status = 'Disabled'
            elif user['status'] == 1:
                user_status = 'Validation Pending'
            elif user['status'] == 2:
                user_status = 'Enabled'
            else:
                user_status = 'N/A'

            status_list.append(user_status)
            #get authority
            #if user['config']:
            user_config = json.loads(user['config'])
            user_authority = user_config.get('authority','N/A')
            authority_list.append(user_authority)
    
        user_list = [{'email': t[0], 'status': t[1], 'authority':t[2]}
            for t in zip(email_list, status_list, authority_list)]

            
        #page.enqueue_query(user_query)

        #page.expose_js_metadata()
        #userlist = QueryTable(
        #    page  = page,
        #    title = 'List',
        #    domid = 'checkboxes',
        #    # this is the query at the core of the slice list
        #    query = user_query,
        #    query_all = user_query,
        #    checkboxes = False,
        #    init_key   = 'user',
        #    datatables_options = { 
        #        'iDisplayLength': 10,
        #        'bLengthChange' : True,
        #        'bAutoWidth'    : True,
        #        },
        #)

        context = super(UsersView, self).get_context_data(**kwargs)
        context['person']   = self.request.user
        context['user_list'] = user_list

        # XXX This is repeated in all pages
        # more general variables expected in the template
        context['title'] = 'Users in MySlice'
        # the menu items on the top
        context['topmenu_items'] = topmenu_items_live('Users', page)
        # so we can sho who is logged
        context['username'] = the_user(self.request)

        context.update(page.prelude_env())

        context['layout_1_or_2']="layout-unfold2.html" if not context['username'] else "layout-unfold1.html"

        return context