X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=portal%2Fviews.py;h=27455f2e4158e09d9e9af98d0621ea92d8db9226;hb=d9fa97447cdfd1fc896d840f7b3bebbb3d2bd921;hp=74f8eec63034a6386e517c00c06ccc3fc3f9bf76;hpb=81969a7eda1f53797b579d0bd6a71e96c26e610b;p=myslice.git diff --git a/portal/views.py b/portal/views.py index 74f8eec6..27455f2e 100644 --- a/portal/views.py +++ b/portal/views.py @@ -1,10 +1,11 @@ # -*- coding: utf-8 -*- # -# portal/urls.py: URL mappings for the portal application +# portal/views.py: views for the portal application # This file is part of the Manifold project. # # Authors: # Jordan Augé +# Mohammed Yasin Rahman # Copyright 2013, UPMC Sorbonne Universités / LIP6 # # This program is free software; you can redistribute it and/or modify it under @@ -20,39 +21,209 @@ # this program; see the file COPYING. If not, write to the Free Software # Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -from django.shortcuts import render -from portal.forms import RegisterUserForm +from django.conf import settings +from django.contrib.sites.models import Site, RequestSite +from django.contrib import messages +from django.views.generic import View +from django.views.generic.base import TemplateView +from django.shortcuts import render +from plugins.lists.simplelist import SimpleList +from portal import signals +from portal.forms import UserRegisterForm, SliceRequestForm, ContactForm +from portal.util import RegistrationView, ActivationView +from portal.models import PendingUser, PendingSlice +from manifold.core.query import Query +from unfold.page import Page +from myslice.viewutils import topmenu_items, the_user +from django.http import HttpResponseRedirect -def user_register(request): - if request.method == 'POST': - form = RegisterUserForm(request.POST) # Nous reprenons les données - if form.is_valid(): - first_name = form.cleaned_data['first_name'] - last_name = form.cleaned_data['last_name'] - email = form.cleaned_data['email'] - password = form.cleaned_data['password'] - password2 = form.cleaned_data['password2'] - keypair = form.cleaned_data['keypair'] - ## Ici nous pouvons traiter les données du formulaire - #sujet = form.cleaned_data['sujet'] - #message = form.cleaned_data['message'] - #envoyeur = form.cleaned_data['envoyeur'] - #renvoi = form.cleaned_data['renvoi'] - ## Nous pourrions ici envoyer l'e-mail grâce aux données que nous venons de récupérer - #envoi = True - else: - form = RegisterUserForm() - return render(request, 'register_user.html', locals()) - pass +class DashboardView(TemplateView): + template_name = "dashboard.html" -def user_validate(request): - pass + def get_context_data(self, **kwargs): + user_hrn = 'ple.upmc.jordan_auge' -def slice_request(request): - pass + #messages.info(self.request, 'You have logged in') + page = Page(self.request) + + # Slow... + #slice_query = Query().get('slice').filter_by('user.user_hrn', 'contains', user_hrn).select('slice_hrn') + slice_query = Query().get('user').filter_by('user_hrn', '==', user_hrn).select('user_hrn', 'slice.slice_hrn') + auth_query = Query().get('network').select('network_hrn') + page.enqueue_query(slice_query) + page.enqueue_query(auth_query) + + page.expose_queries() + + slicelist = SimpleList( + title = None, + page = page, + key = 'slice.slice_hrn', + query = slice_query, + ) + + authlist = SimpleList( + title = None, + page = page, + key = 'network_hrn', + query = auth_query, + ) + + context = super(DashboardView, self).get_context_data(**kwargs) + context['person'] = self.request.user + context['networks'] = authlist.render(self.request) + context['slices'] = slicelist.render(self.request) + + # XXX This is repeated in all pages + # more general variables expected in the template + context['title'] = 'Test view that combines various plugins' + # the menu items on the top + context['topmenu_items'] = topmenu_items('Dashboard', self.request) + # so we can sho who is logged + context['username'] = the_user(self.request) + + context.update(page.prelude_env()) + + return context + +class UserRegisterView(RegistrationView): + """ + A registration backend which follows a simple workflow: + + 1. User signs up, inactive account is created. + + 2. Email is sent to user with activation link. + + 3. User clicks activation link, account is now active. + + Using this backend requires that + + * ``registration`` be listed in the ``INSTALLED_APPS`` setting + (since this backend makes use of models defined in this + application). + + * The setting ``ACCOUNT_ACTIVATION_DAYS`` be supplied, specifying + (as an integer) the number of days from registration during + which a user may activate their account (after that period + expires, activation will be disallowed). + + * The creation of the templates + ``registration/activation_email_subject.txt`` and + ``registration/activation_email.txt``, which will be used for + the activation email. See the notes for this backends + ``register`` method for details regarding these templates. + + Additionally, registration can be temporarily closed by adding the + setting ``REGISTRATION_OPEN`` and setting it to + ``False``. Omitting this setting, or setting it to ``True``, will + be interpreted as meaning that registration is currently open and + permitted. + + Internally, this is accomplished via storing an activation key in + an instance of ``registration.models.RegistrationProfile``. See + that model and its custom manager for full documentation of its + fields and supported operations. + + """ + form_class = UserRegisterForm + + def register(self, request, **cleaned_data): + """ + Given a username, email address and password, register a new + user account, which will initially be inactive. + + Along with the new ``User`` object, a new + ``registration.models.RegistrationProfile`` will be created, + tied to that ``User``, containing the activation key which + will be used for this account. + + An email will be sent to the supplied email address; this + email should contain an activation link. The email will be + rendered using two templates. See the documentation for + ``RegistrationProfile.send_activation_email()`` for + information about these templates and the contexts provided to + them. + + After the ``User`` and ``RegistrationProfile`` are created and + the activation email is sent, the signal + ``registration.signals.user_registered`` will be sent, with + the new ``User`` as the keyword argument ``user`` and the + class of this backend as the sender. + + """ + first_name = cleaned_data['first_name'] + last_name = cleaned_data['last_name'] + affiliation= cleaned_data['affiliation'] + email = cleaned_data['email'] + password = cleaned_data['password1'] + + #password2 = cleaned_data['password2'] + keypair = cleaned_data['keypair'] + + #if Site._meta.installed: + # site = Site.objects.get_current() + #else: + # site = RequestSite(request) + site = None + + new_user = PendingUser.objects.create_inactive_user(first_name, last_name, email, password, site) + signals.user_registered.send(sender=self.__class__, + user=new_user, + request=request) + return new_user + + def get_context_data(self, **kwargs): + context = super(UserRegisterView, self).get_context_data(**kwargs) + context['topmenu_items'] = topmenu_items('Register', self.request) + context['username'] = the_user (self.request) + return context + + def registration_allowed(self, request): + """ + Indicate whether account registration is currently permitted, + based on the value of the setting ``REGISTRATION_OPEN``. This + is determined as follows: + + * If ``REGISTRATION_OPEN`` is not specified in settings, or is + set to ``True``, registration is permitted. + + * If ``REGISTRATION_OPEN`` is both specified and set to + ``False``, registration is not permitted. + + """ + return getattr(settings, 'REGISTRATION_OPEN', True) + + def get_success_url(self, request, user): + """ + Return the name of the URL to redirect to after successful + user registration. + + """ + return ('user_register_complete', (), {}) + + +class UserValidateView(ActivationView): + def activate(self, request, activation_key): + """ + Given an an activation key, look up and activate the user + account corresponding to that key (if possible). + + After successful activation, the signal + ``registration.signals.user_activated`` will be sent, with the + newly activated ``User`` as the keyword argument ``user`` and + the class of this backend as the sender. + + """ + activated_user = RegistrationProfile.objects.activate_user(activation_key) + if activated_user: + signals.user_activated.send(sender=self.__class__, + user=activated_user, + request=request) + return activated_user + + def get_success_url(self, request, user): + return ('registration_activation_complete', (), {}) -def slice_validate(request): - pass # DEPRECATED #from portal.portalpage import PortalPage # DEPRECATED #from plugins.wizard import Wizard @@ -86,8 +257,8 @@ def slice_validate(request): # DEPRECATED ## }) # DEPRECATED ## return super(MerlinWizard, cls).as_view(*args, **kwargs) # DEPRECATED # -# DEPRECATED #class RegisterUserWizardView(NamedUrlSessionWizardView): -# DEPRECATED ##class RegisterUserWizardView(LoginRequiredMixin, NamedUrlSessionWizardView): +# DEPRECATED #class UserRegisterWizardView(NamedUrlSessionWizardView): +# DEPRECATED ##class UserRegisterWizardView(LoginRequiredMixin, NamedUrlSessionWizardView): # DEPRECATED # # Notice that I specify a file storage instance. If you don't specify this, # DEPRECATED # # and you need to support FileField or ImageField in your forms, you'll get # DEPRECATED # # errors from Django. This is something else I think could be handled by @@ -125,7 +296,7 @@ def slice_validate(request): # DEPRECATED #def register_user(request): # DEPRECATED # # DEPRECATED # if request.method == 'POST': -# DEPRECATED # form = RegisterUserForm(request.POST) # Nous reprenons les données +# DEPRECATED # form = UserRegisterForm(request.POST) # Nous reprenons les données # DEPRECATED # if form.is_valid(): # DEPRECATED # first_name = form.cleaned_data['first_name'] # DEPRECATED # last_name = form.cleaned_data['last_name'] @@ -141,7 +312,7 @@ def slice_validate(request): # DEPRECATED # ## Nous pourrions ici envoyer l'e-mail grâce aux données que nous venons de récupérer # DEPRECATED # #envoi = True # DEPRECATED # else: -# DEPRECATED # form = RegisterUserForm() +# DEPRECATED # form = UserRegisterForm() # DEPRECATED # return render(request, 'register_user.html', locals()) # DEPRECATED # # DEPRECATED #def index(request): @@ -257,3 +428,127 @@ def slice_validate(request): # DEPRECATED # p << wizard.render(request) # in portal page if possible # DEPRECATED # # DEPRECATED # return p.render() + +class MyAccountView(TemplateView): + template_name = "my_account.html" + + def get_context_data(self, **kwargs): + #user_hrn = 'ple.upmc.jordan_auge' + + #messages.info(self.request, 'You have logged in') + page = Page(self.request) + + # Slow... + #slice_query = Query().get('slice').filter_by('user.user_hrn', 'contains', user_hrn).select('slice_hrn') + #slice_query = Query().get('user').filter_by('user_hrn', '==', user_hrn).select('slice.slice_hrn') + #auth_query = Query().get('network').select('network_hrn') + #page.enqueue_query(slice_query) + #page.enqueue_query(auth_query) + + #page.expose_queries() + + #slicelist = SimpleList( + # title = None, + # page = page, + # key = 'slice.slice_hrn', + # query = slice_query, + #) + + #authlist = SimpleList( + # title = None, + # page = page, + # key = 'network_hrn', + # query = auth_query, + #) + + context = super(MyAccountView, self).get_context_data(**kwargs) + context['person'] = self.request.user + #context['networks'] = authlist.render(self.request) + #context['slices'] = slicelist.render(self.request) + + # XXX This is repeated in all pages + # more general variables expected in the template + context['title'] = 'User Profile Page' + # the menu items on the top + context['topmenu_items'] = topmenu_items('my_account', self.request) + # so we can sho who is logged + context['username'] = the_user(self.request) + + context.update(page.prelude_env()) + + return context + + + + + + + +# view for contact form +def contact(request): + if request.method == 'POST': # If the form has been submitted... + form = ContactForm(request.POST) # A form bound to the POST data + if form.is_valid(): # All validation rules pass + # Process the data in form.cleaned_data + first_name = form.cleaned_data['first_name'] + last_name = form.cleaned_data['last_name'] + affiliation = form.cleaned_data['affiliation'] + subject = form.cleaned_data['subject'] + message = form.cleaned_data['message'] + email = form.cleaned_data['email'] # email of the sender + cc_myself = form.cleaned_data['cc_myself'] + + recipients = ['yasin.upmc@gmail.com'] + if cc_myself: + recipients.append(email) + + from django.core.mail import send_mail + send_mail("Onelab user submitted a query ", [first_name,last_name,affiliation,subject,message], email, recipients) + return render(request,'contact_sent.html') # Redirect after POST + else: + form = ContactForm() # An unbound form + + return render(request, 'contact.html', { + 'form': form, + }) + + +def slice_request(request): + if request.method == 'POST': # If the form has been submitted... + form = SliceRequestForm(request.POST) # A form bound to the POST data + if form.is_valid(): # All validation rules pass + # Process the data in form.cleaned_data + slice_name = form.cleaned_data['slice_name'] + number_of_nodes = form.cleaned_data['number_of_nodes'] + type_of_nodes = form.cleaned_data['type_of_nodes'] + purpose = form.cleaned_data['purpose'] + email = form.cleaned_data['email'] # email of the sender + cc_myself = form.cleaned_data['cc_myself'] + + recipients = ['yasin.upmc@gmail.com','jordan.auge@lip6.fr'] + if cc_myself: + recipients.append(email) + + from django.core.mail import send_mail + send_mail("Onelab New Slice request form submitted", [slice_name,number_of_nodes,type_of_nodes,purpose], email, recipients) + return render(request,'slicereq_recvd.html') # Redirect after POST + else: + form = SliceRequestForm() # An unbound form + +# template_env = {} +# template_env['form'] = form +# template_env['topmenu_items'] = topmenu_items('Request a slice', request) +# template_env['unfold1_main'] = render(request, 'slice_request_.html', { +# 'form': form, +# }) +# from django.shortcuts import render_to_response +# from django.template import RequestContext +# return render_to_response ('view-unfold1.html',template_env, +# context_instance=RequestContext(request)) + + return render(request, 'slice_request.html', { + 'form': form, + 'topmenu_items': topmenu_items('Request a slice', request), + 'username': the_user (request) + }) +