1 # -*- coding: utf-8 -*-
3 # portal/views.py: views for the portal application
4 # This file is part of the Manifold project.
7 # Jordan Augé <jordan.auge@lip6.fr>
8 # Mohammed Yasin Rahman <mohammed-yasin.rahman@lip6.fr>
9 # Copyright 2013, UPMC Sorbonne Universités / LIP6
11 # This program is free software; you can redistribute it and/or modify it under
12 # the terms of the GNU General Public License as published by the Free Software
13 # Foundation; either version 3, or (at your option) any later version.
15 # This program is distributed in the hope that it will be useful, but WITHOUT
16 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
17 # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
20 # You should have received a copy of the GNU General Public License along with
21 # this program; see the file COPYING. If not, write to the Free Software
22 # Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
24 from django.conf import settings
25 from django.contrib.sites.models import Site, RequestSite
26 from django.contrib import messages
27 from django.views.generic import View
28 from django.views.generic.base import TemplateView
29 from django.shortcuts import render
31 from plugins.lists.simplelist import SimpleList
33 #from plugins.pres_view import PresView
34 from portal.event import Event
37 from portal import signals
38 from portal.forms import UserRegisterForm, SliceRequestForm, ContactForm
39 from portal.util import RegistrationView, ActivationView
40 from portal.models import PendingUser, PendingSlice
41 from manifold.core.query import Query
42 from unfold.page import Page
43 from myslice.viewutils import topmenu_items, the_user
44 from django.http import HttpResponseRedirect, HttpResponse
47 class DashboardView(TemplateView):
48 template_name = "dashboard.html"
50 def get_context_data(self, **kwargs):
51 # We might have slices on different registries with different user accounts
52 # We note that this portal could be specific to a given registry, to which we register users, but i'm not sure that simplifies things
53 # Different registries mean different identities, unless we identify via SFA HRN or have associated the user email to a single hrn
55 #messages.info(self.request, 'You have logged in')
56 page = Page(self.request)
59 #slice_query = Query().get('slice').filter_by('user.user_hrn', 'contains', user_hrn).select('slice_hrn')
60 slice_query = Query().get('user').filter_by('user_hrn', '==', '$user_hrn').select('user_hrn', 'slice.slice_hrn')
61 auth_query = Query().get('network').select('network_hrn')
62 page.enqueue_query(slice_query)
63 page.enqueue_query(auth_query)
67 slicelist = SimpleList(
70 key = 'slice.slice_hrn',
74 authlist = SimpleList(
81 context = super(DashboardView, self).get_context_data(**kwargs)
82 context['person'] = self.request.user
83 context['networks'] = authlist.render(self.request)
84 context['slices'] = slicelist.render(self.request)
86 # XXX This is repeated in all pages
87 # more general variables expected in the template
88 context['title'] = 'Test view that combines various plugins'
89 # the menu items on the top
90 context['topmenu_items'] = topmenu_items('Dashboard', self.request)
91 # so we can sho who is logged
92 context['username'] = the_user(self.request)
94 context.update(page.prelude_env())
98 class UserRegisterView(RegistrationView):
100 A registration backend which follows a simple workflow:
102 1. User signs up, inactive account is created.
104 2. Email is sent to user with activation link.
106 3. User clicks activation link, account is now active.
108 Using this backend requires that
110 * ``registration`` be listed in the ``INSTALLED_APPS`` setting
111 (since this backend makes use of models defined in this
114 * The setting ``ACCOUNT_ACTIVATION_DAYS`` be supplied, specifying
115 (as an integer) the number of days from registration during
116 which a user may activate their account (after that period
117 expires, activation will be disallowed).
119 * The creation of the templates
120 ``registration/activation_email_subject.txt`` and
121 ``registration/activation_email.txt``, which will be used for
122 the activation email. See the notes for this backends
123 ``register`` method for details regarding these templates.
125 Additionally, registration can be temporarily closed by adding the
126 setting ``REGISTRATION_OPEN`` and setting it to
127 ``False``. Omitting this setting, or setting it to ``True``, will
128 be interpreted as meaning that registration is currently open and
131 Internally, this is accomplished via storing an activation key in
132 an instance of ``registration.models.RegistrationProfile``. See
133 that model and its custom manager for full documentation of its
134 fields and supported operations.
137 form_class = UserRegisterForm
139 def register(self, request, **cleaned_data):
141 Given a username, email address and password, register a new
142 user account, which will initially be inactive.
144 Along with the new ``User`` object, a new
145 ``registration.models.RegistrationProfile`` will be created,
146 tied to that ``User``, containing the activation key which
147 will be used for this account.
149 An email will be sent to the supplied email address; this
150 email should contain an activation link. The email will be
151 rendered using two templates. See the documentation for
152 ``RegistrationProfile.send_activation_email()`` for
153 information about these templates and the contexts provided to
156 After the ``User`` and ``RegistrationProfile`` are created and
157 the activation email is sent, the signal
158 ``registration.signals.user_registered`` will be sent, with
159 the new ``User`` as the keyword argument ``user`` and the
160 class of this backend as the sender.
163 first_name = cleaned_data['first_name']
164 last_name = cleaned_data['last_name']
165 affiliation= cleaned_data['affiliation']
166 email = cleaned_data['email']
167 password = cleaned_data['password1']
169 #password2 = cleaned_data['password2']
170 keypair = cleaned_data['keypair']
172 #if Site._meta.installed:
173 # site = Site.objects.get_current()
175 # site = RequestSite(request)
178 new_user = PendingUser.objects.create_inactive_user(first_name, last_name, email, password, site)
179 signals.user_registered.send(sender=self.__class__,
184 def get_context_data(self, **kwargs):
185 context = super(UserRegisterView, self).get_context_data(**kwargs)
186 context['topmenu_items'] = topmenu_items('Register', self.request)
187 context['username'] = the_user (self.request)
190 def registration_allowed(self, request):
192 Indicate whether account registration is currently permitted,
193 based on the value of the setting ``REGISTRATION_OPEN``. This
194 is determined as follows:
196 * If ``REGISTRATION_OPEN`` is not specified in settings, or is
197 set to ``True``, registration is permitted.
199 * If ``REGISTRATION_OPEN`` is both specified and set to
200 ``False``, registration is not permitted.
203 return getattr(settings, 'REGISTRATION_OPEN', True)
205 def get_success_url(self, request, user):
207 Return the name of the URL to redirect to after successful
211 return ('user_register_complete', (), {})
214 class UserValidateView(ActivationView):
215 def activate(self, request, activation_key):
217 Given an an activation key, look up and activate the user
218 account corresponding to that key (if possible).
220 After successful activation, the signal
221 ``registration.signals.user_activated`` will be sent, with the
222 newly activated ``User`` as the keyword argument ``user`` and
223 the class of this backend as the sender.
226 activated_user = RegistrationProfile.objects.activate_user(activation_key)
228 signals.user_activated.send(sender=self.__class__,
231 return activated_user
233 def get_success_url(self, request, user):
234 return ('registration_activation_complete', (), {})
237 # DEPRECATED #from portal.portalpage import PortalPage
238 # DEPRECATED #from plugins.wizard import Wizard
239 # DEPRECATED #from plugins.form import CreateForm
240 # DEPRECATED #from plugins.raw.raw import Raw # XXX
242 # DEPRECATED #from myslice.viewutils import the_user
244 # DEPRECATED #from django.template.loader import render_to_string
245 # DEPRECATED #from django.template import RequestContext
246 # DEPRECATED #from django.views import generic
248 # DEPRECATED #from django.contrib.formtools.wizard.views import NamedUrlSessionWizardView
249 # DEPRECATED ##from django.core.files.storage import FileSystemStorage
250 # DEPRECATED #from django.core.files.storage import default_storage
252 # DEPRECATED ##class MerlinWizard(NamedUrlSessionWizardView):
257 # DEPRECATED ## @classonlymethod
258 # DEPRECATED ## def as_view(cls, *args, **kwargs):
259 # DEPRECATED ## kwargs.update({
260 # DEPRECATED ## 'form_list': [
261 # DEPRECATED ## NameForm,
262 # DEPRECATED ## QuestForm,
263 # DEPRECATED ## ColorForm,
265 # DEPRECATED ## 'url_name': 'merlin_wizard'
267 # DEPRECATED ## return super(MerlinWizard, cls).as_view(*args, **kwargs)
269 # DEPRECATED #class UserRegisterWizardView(NamedUrlSessionWizardView):
270 # DEPRECATED ##class UserRegisterWizardView(LoginRequiredMixin, NamedUrlSessionWizardView):
271 # DEPRECATED # # Notice that I specify a file storage instance. If you don't specify this,
272 # DEPRECATED # # and you need to support FileField or ImageField in your forms, you'll get
273 # DEPRECATED # # errors from Django. This is something else I think could be handled by
274 # DEPRECATED # # the views better. Seems to me that it should just use whatever the
275 # DEPRECATED # # default/specified storage is for the rest of your project/application.
276 # DEPRECATED # file_storage = default_storage # FileSystemStorage()
277 # DEPRECATED # template_name = "register_user_wizard.html"
279 # DEPRECATED # def done(self, form_list, **kwargs):
280 # DEPRECATED # step1_form = form_list[0]
281 # DEPRECATED # step2_form = form_list[1]
283 # DEPRECATED # productext = self.create_product(product_form)
284 # DEPRECATED # shippings = self.create_shippings(productext, shipping_forms)
285 # DEPRECATED # images = self.create_images(productext, image_forms)
287 # DEPRECATED # if all([productext, shippings, images]):
288 # DEPRECATED # del self.request.session["wizard_product_wizard_view"]
290 # DEPRECATED # messages.success(self.request,
291 # DEPRECATED # _("Your product has been created."))
292 # DEPRECATED # return HttpResponseRedirect(self.get_success_url(productext))
294 # DEPRECATED # messages.error(self.request, _("Something went wrong creating your "
295 # DEPRECATED # "product. Please try again or contact support."))
296 # DEPRECATED # return HttpResponseRedirect(reverse("register_wizard"))
298 # DEPRECATED # #def get_form_kwargs(self, step):
299 # DEPRECATED # # if step == "product":
300 # DEPRECATED # # return {"user": self.request.user}
301 # DEPRECATED # # return {}
303 # DEPRECATED ## The portal should hook the slice and user creation pages
305 # DEPRECATED #def register_user(request):
307 # DEPRECATED # if request.method == 'POST':
308 # DEPRECATED # form = UserRegisterForm(request.POST) # Nous reprenons les données
309 # DEPRECATED # if form.is_valid():
310 # DEPRECATED # first_name = form.cleaned_data['first_name']
311 # DEPRECATED # last_name = form.cleaned_data['last_name']
312 # DEPRECATED # email = form.cleaned_data['email']
313 # DEPRECATED # password = form.cleaned_data['password']
314 # DEPRECATED # password2 = form.cleaned_data['password2']
315 # DEPRECATED # keypair = form.cleaned_data['keypair']
316 # DEPRECATED # ## Ici nous pouvons traiter les données du formulaire
317 # DEPRECATED # #sujet = form.cleaned_data['sujet']
318 # DEPRECATED # #message = form.cleaned_data['message']
319 # DEPRECATED # #envoyeur = form.cleaned_data['envoyeur']
320 # DEPRECATED # #renvoi = form.cleaned_data['renvoi']
321 # DEPRECATED # ## Nous pourrions ici envoyer l'e-mail grâce aux données que nous venons de récupérer
322 # DEPRECATED # #envoi = True
324 # DEPRECATED # form = UserRegisterForm()
325 # DEPRECATED # return render(request, 'register_user.html', locals())
327 # DEPRECATED #def index(request):
329 # DEPRECATED # WIZARD_TITLE = 'User registration'
330 # DEPRECATED # STEP1_TITLE = 'Enter your details'
331 # DEPRECATED # STEP2_TITLE = 'Select your institution'
332 # DEPRECATED # STEP3_TITLE = 'Authentication'
333 # DEPRECATED # STEP4_TITLE = 'Request a slice (optional)'
334 # DEPRECATED # STEP5_TITLE = 'Waiting for validation'
335 # DEPRECATED # STEP6_TITLE = 'Account validated'
337 # DEPRECATED # STEP0 = render_to_string('account_validated.html', context_instance=RequestContext(request))
338 # DEPRECATED # STEP2_HTML = """
339 # DEPRECATED # coucou
341 # DEPRECATED # STEP4 = """
344 # DEPRECATED # STEP5 = render_to_string('account_validated.html', context_instance=RequestContext(request))
346 # DEPRECATED # p = PortalPage(request)
348 # DEPRECATED # # This is redundant with the Wizard title
349 # DEPRECATED # p << "<h3>User registration</h3>"
351 # DEPRECATED # sons = []
352 # DEPRECATED # start_step = 1
354 # DEPRECATED # # STEP 1
355 # DEPRECATED # # If the user already exists (is logged), let's display a summary of his account details
356 # DEPRECATED # # Otherwise propose a form to fill in
357 # DEPRECATED # if the_user(request):
358 # DEPRECATED # # Fill a disabled form with user info
359 # DEPRECATED # # Please logout to register another user
360 # DEPRECATED # sons.append(Raw(page=p, title=STEP1_TITLE, togglable=False, html=STEP0))
361 # DEPRECATED # start_step += 1
363 # DEPRECATED # # We could pass a list of fields also, instead of retrieving them from metadata
364 # DEPRECATED # # Otherwise we need some heuristics to display nice forms
365 # DEPRECATED # # XXX Could we log the user in after the form is validated ?
366 # DEPRECATED # # XXX Explain the password is for XXX
367 # DEPRECATED # field_list = [{
368 # DEPRECATED # 'name' : 'First name',
369 # DEPRECATED # 'field' : 'firstname',
370 # DEPRECATED # 'type' : 'text',
371 # DEPRECATED # 'validate_rx' : '^[a-zA-Z -]+$',
372 # DEPRECATED # 'validate_err': 'Your first name must be comprised of letters only',
373 # DEPRECATED # 'description' : 'Enter your first name',
375 # DEPRECATED # 'name' : 'Last name',
376 # DEPRECATED # 'field' : 'lastname',
377 # DEPRECATED # 'type' : 'text',
378 # DEPRECATED # 'validate_rx' : '^[a-zA-Z -]+$',
379 # DEPRECATED # 'validate_err': 'Your last name must be comprised of letters only',
380 # DEPRECATED # 'description' : 'Enter your last name',
382 # DEPRECATED # 'name' : 'Email',
383 # DEPRECATED # 'field' : 'email',
384 # DEPRECATED # 'type' : 'text',
385 # DEPRECATED # 'description' : 'Enter your email address',
387 # DEPRECATED # 'name' : 'Password',
388 # DEPRECATED # 'field' : 'password',
389 # DEPRECATED # 'type' : 'password',
390 # DEPRECATED # 'description' : 'Enter your password',
392 # DEPRECATED # 'name' : 'Confirm password',
393 # DEPRECATED # 'field' : 'password2',
394 # DEPRECATED # 'type' : 'password',
395 # DEPRECATED # 'description' : 'Enter your password again',
397 # DEPRECATED # sons.append(CreateForm(page = p, title = STEP1_TITLE, togglable = False, object = 'local:user', fields = field_list))
399 # DEPRECATED # # STEP 2
400 # DEPRECATED # # If the user already exists (is logged), let's display a summary of its institution
401 # DEPRECATED # # Otherwise propose a form to fill in (we should base our selection on the email)
402 # DEPRECATED # if the_user(request):
403 # DEPRECATED # # Fill a disabled form with institution
404 # DEPRECATED # # Please logout to register another user
405 # DEPRECATED # sons.append(Raw(page=p, title=STEP2_TITLE, togglable=False, html="User created"))
406 # DEPRECATED # start_step += 1
408 # DEPRECATED # sons.append(CreateForm(page = p, title = STEP2_TITLE, togglable = False, object = 'slice')) #institution'))
410 # DEPRECATED # # STEP3
411 # DEPRECATED # # Please should your prefered authentication method
412 # DEPRECATED # # This step should allow the user to either choose the user or managed mode in MySlice
413 # DEPRECATED # sons.append(Raw(page = p, title = STEP3_TITLE, togglable = False, html = STEP2_HTML))
415 # DEPRECATED # # Step 4: Request a slice (optional)
416 # DEPRECATED # sons.append(CreateForm(page = p, title = STEP4_TITLE, togglable = False, object = 'slice'))
418 # DEPRECATED # # Step 5: Your request is waiting for validation
419 # DEPRECATED # # Periodic refresh
420 # DEPRECATED # sons.append(Raw(page = p, title = STEP5_TITLE, togglable = False, html = STEP4))
422 # DEPRECATED # # Step 6: Account validation = welcome for newly validated users
423 # DEPRECATED # # . delegation
424 # DEPRECATED # # . platforms
425 # DEPRECATED # # . slice
426 # DEPRECATED # # . pointers
427 # DEPRECATED # sons.append(Raw(page = p, title = STEP6_TITLE, togglable = False, html = STEP5))
429 # DEPRECATED # wizard = Wizard(
430 # DEPRECATED # page = p,
431 # DEPRECATED # title = WIZARD_TITLE,
432 # DEPRECATED # togglable = False,
433 # DEPRECATED # sons = sons,
434 # DEPRECATED # start_step = start_step,
437 # DEPRECATED # p << wizard.render(request) # in portal page if possible
439 # DEPRECATED # return p.render()
442 # DEPRECATED ## view for my_account
443 # DEPRECATED # class MyAccountView(TemplateView):
444 # DEPRECATED # template_name = "my_account.html"
446 # DEPRECATED # def from_process(self, request, **cleaned_data):
447 # DEPRECATED # #if request.method == 'POST':
448 # DEPRECATED # # if request.POST['submit_name']:
449 # DEPRECATED # if 'fname' in request.POST:
450 # DEPRECATED # messsag= "Got Name"
451 # DEPRECATED # #return render(request, 'portal/my_account.html')
452 # DEPRECATED # #response = HttpResponse("Here's the text of the Web page.")
453 # DEPRECATED # return HttpResponse(message)
455 # DEPRECATED # def get_context_data(self, **kwargs):
456 # DEPRECATED # page = Page(self.request)
457 # DEPRECATED # context = super(MyAccountView, self).get_context_data(**kwargs)
458 # DEPRECATED # context['person'] = self.request.user
459 # DEPRECATED # # XXX This is repeated in all pages
460 # DEPRECATED # # more general variables expected in the template
461 # DEPRECATED # context['title'] = 'User Profile Page'
462 # DEPRECATED # # the menu items on the top
463 # DEPRECATED # context['topmenu_items'] = topmenu_items('my_account', self.request)
464 # DEPRECATED # # so we can sho who is logged
465 # DEPRECATED # context['username'] = the_user(self.request)
466 # DEPRECATED # context.update(page.prelude_env())
467 # DEPRECATED # return context
471 # View for my_account form
472 def my_account(request):
473 return render(request, 'my_account.html')
475 #my_acc form value processing
476 def acc_process(request):
477 # getting the user_id from the session [now hardcoded]
478 get_user = PendingUser.objects.get(id='1') # here we will get the id/email from session e.g., person.email
479 if 'submit_name' in request.POST:
480 edited_first_name = request.POST['fname']
481 edited_last_name = request.POST['lname']
482 #email = 'test_email@gmail.com'
483 #password = 'test_pp'
484 #message = 'F_Name: %s L_name: %s dummy_pp: %s' % (first_name, last_name, password)
487 # insert into DB [needed for registration page]
488 #approach borrowed from register view
489 #new_user = PendingUser.objects.create_inactive_user(edited_first_name, edited_last_name, email, password, site)
490 #conventional approach
491 #b = PendingUser(first_name=edited_first_name, edited_last_name=last_name)
494 # select and update [will be used throughout this view]
495 # select the logged in user [for the moment hard coded]
496 #get_user = PendingUser.objects.get(id='1') # here we will get the id/email from session e.g., person.email
497 # update first and last name
498 get_user.first_name = edited_first_name
499 get_user.last_name = edited_last_name
502 return HttpResponse('Success: Name Updated!!')
503 elif 'submit_pass' in request.POST:
504 edited_password = request.POST['password']
505 # select the logged in user [for the moment hard coded]
506 #get_user = PendingUser.objects.get(id='1') # here we will get the id/email from session e.g., person.email
508 get_user.password = edited_password
510 return HttpResponse('Success: Password Changed!!')
511 elif 'generate' in request.POST:
513 from M2Crypto import Rand, RSA, BIO
517 def blank_callback():
518 "Replace the default dashes"
522 Rand.rand_seed (os.urandom (KEY_LENGTH))
524 key = RSA.gen_key (KEY_LENGTH, 65537, blank_callback)
525 # Create memory buffers
526 pri_mem = BIO.MemoryBuffer()
527 pub_mem = BIO.MemoryBuffer()
528 # Save keys to buffers
529 key.save_key_bio(pri_mem, None)
530 key.save_pub_key_bio(pub_mem)
533 public_key = pub_mem.getvalue()
534 private_key = pri_mem.getvalue()
536 keypair = '{"user_public_key":"'+ public_key + '", "user_private_key":"'+ private_key + '"}'
537 #keypair = re.sub("\r", "", keypair)
538 #keypair = re.sub("\n", "\\n", keypair)
539 keypair = keypair.rstrip('\r\n')
540 get_user.keypair = keypair
542 return HttpResponse('Success: New Keypair Generated! %s' % keypair)
544 elif 'upload_key' in request.POST:
545 up_file = request.FILES['pubkey']
546 file_content = up_file.read()
547 file_name = up_file.name
548 file_extension = os.path.splitext(file_name)[1]
549 allowed_extension = ['.pub','.txt']
550 if file_extension in allowed_extension:
551 file_content = '{"user_public_key":"'+ file_content +'"}'
552 file_content = re.sub("\r", "", file_content)
553 file_content = re.sub("\n", "\\n",file_content)
554 get_user.keypair = file_content
556 return HttpResponse('Success: Publickey uploaded! Old records overwritten')
558 return HttpResponse('Please upload a valid public key.')
561 message = 'You submitted an empty form.'
562 return HttpResponse(message)
566 # view for contact form
567 def contact(request):
568 if request.method == 'POST': # If the form has been submitted...
569 form = ContactForm(request.POST) # A form bound to the POST data
570 if form.is_valid(): # All validation rules pass
571 # Process the data in form.cleaned_data
572 first_name = form.cleaned_data['first_name']
573 last_name = form.cleaned_data['last_name']
574 affiliation = form.cleaned_data['affiliation']
575 subject = form.cleaned_data['subject']
576 message = form.cleaned_data['message']
577 email = form.cleaned_data['email'] # email of the sender
578 cc_myself = form.cleaned_data['cc_myself']
580 recipients = ['yasin.upmc@gmail.com']
582 recipients.append(email)
584 from django.core.mail import send_mail
585 send_mail("Onelab user submitted a query ", [first_name,last_name,affiliation,subject,message], email, recipients)
586 return render(request,'contact_sent.html') # Redirect after POST
588 form = ContactForm() # An unbound form
590 return render(request, 'contact.html', {
595 def slice_request(request):
596 if request.method == 'POST': # If the form has been submitted...
597 form = SliceRequestForm(request.POST) # A form bound to the POST data
598 if form.is_valid(): # All validation rules pass
599 # Process the data in form.cleaned_data
600 slice_name = form.cleaned_data['slice_name']
601 number_of_nodes = form.cleaned_data['number_of_nodes']
602 type_of_nodes = form.cleaned_data['type_of_nodes']
603 purpose = form.cleaned_data['purpose']
604 email = form.cleaned_data['email'] # email of the sender
605 cc_myself = form.cleaned_data['cc_myself']
607 recipients = ['yasin.upmc@gmail.com','jordan.auge@lip6.fr']
609 recipients.append(email)
611 from django.core.mail import send_mail
612 send_mail("Onelab New Slice request form submitted", [slice_name,number_of_nodes,type_of_nodes,purpose], email, recipients)
613 return render(request,'slicereq_recvd.html') # Redirect after POST
615 form = SliceRequestForm() # An unbound form
618 # template_env['form'] = form
619 # template_env['topmenu_items'] = topmenu_items('Request a slice', request)
620 # template_env['unfold1_main'] = render(request, 'slice_request_.html', {
623 # from django.shortcuts import render_to_response
624 # from django.template import RequestContext
625 # return render_to_response ('view-unfold1.html',template_env,
626 # context_instance=RequestContext(request))
628 return render(request, 'slice_request.html', {
630 'topmenu_items': topmenu_items('Request a slice', request),
631 'username': the_user (request)
635 class PresViewView(TemplateView):
636 template_name = "view-unfold1.html"
638 def get_context_data(self, **kwargs):
640 page = Page(self.request)
642 pres_view = PresView(page = page)
644 context = super(PresViewView, self).get_context_data(**kwargs)
646 #context['ALL_STATIC'] = "all_static"
647 context['unfold1_main'] = pres_view.render(self.request)
649 # XXX This is repeated in all pages
650 # more general variables expected in the template
651 context['title'] = 'Test view that combines various plugins'
652 # the menu items on the top
653 context['topmenu_items'] = topmenu_items('PresView', self.request)
654 # so we can sho who is logged
655 context['username'] = the_user(self.request)
657 prelude_env = page.prelude_env()
658 context.update(prelude_env)
662 def json_me(config_file,type):
664 for ligne in config_file:
665 if not ligne.startswith('#'):
666 args = ligne.split(';')
667 json_answer += str('{ "name": "' + args[0] + '" ,"id":"' + args[1] + '" ,"descriptif":"' + args[2]+'"')
669 json_answer += str(',"contraints":')
671 json_answer += str('""')
673 json_answer += str(args[3])
674 json_answer += str('},')
675 return json_answer[:-1]
678 DIR = '/var/myslice/'
679 STATIC = '%s/config_method_static' % DIR
680 DYNAMIC = '%s/config_method_dynamic' % DIR
681 ANIMATION = '%s/config_method_animation' % DIR
683 def pres_view_methods(request, type):
687 elif type =="static":
688 config = open(STATIC, "r")
689 json_answer = str('{ "options": [')
690 json_answer += str(json_me(config,"static"))
691 json_answer += str('] }')
693 elif type =="dynamic":
694 config = open(DYNAMIC, "r")
695 json_answer = str('{ "options": [')
696 json_answer += str(json_me(config,"dynamic"))
697 json_answer += str('] }')
699 elif type =="animation":
700 config = open(ANIMATION, "r")
701 json_answer = str('{ "options": [')
702 json_answer += str(json_me(config,"animation"))
703 json_answer += str('] }')
706 config = open(STATIC, "r")
707 json_answer = str('{ "static": [')
708 json_answer += str(json_me(config,"static"))
709 json_answer += str('],')
710 json_answer += str('"dynamic": [')
712 config = open(DYNAMIC, "r")
713 json_answer += str(json_me(config,"dynamic"))
714 json_answer += str('],')
715 json_answer += str('"animation": [')
717 config = open(ANIMATION, "r")
718 json_answer += str(json_me(config,"animation"))
719 json_answer += str('] }')
723 return HttpResponse (json_answer, mimetype="application/json")
725 def pres_view_animation(request, constraints, id):
727 # sites crees depuis 2008
728 # static.py?contraints=']date_created':1262325600&id='name_id"'
730 # method = request.getvalue('method') #ex : GetSites
731 #constraints = "']date_created':1262325600"
737 # method = 'GetSites'#request.getvalue('method') #ex : GetSites
738 # constraints = {}#request.getvalue('constraints') // nul = {}
739 # response_field = "'site_id','name','date_created'"#request.getvalue('response_field')
741 config_file = open(ANIMATION, "r")
742 for ligne in config_file:
743 if not ligne.startswith('#'):
744 ligne = ligne.split('\n')
745 first = ligne[0].split(';')
746 if (str(first[1]) == str(id)):
750 #Les print_method, print_option sont definis par le client (js)
751 #Les animations acceptent que les connexions anonymous
752 # args = "postmsg;animation;;;anonymous;https://www.planet-lab.eu/PLCAPI/;"
753 args = ";;"+str(save[8])+";"+str(save[9])+";anonymous;"+str(save[5])+";"+str(save[6])+";{"+str(constraints)+"};"+str(save[7])+";"
756 #Creation d'un objet event
760 "print_options": event.print_options,
761 "print_method": event.print_method,
762 "message": event.data
767 json_answer = json.dumps(cmd)
768 return HttpResponse (json_answer, mimetype="application/json")
770 def pres_view_static(request, constraints, id):
771 #constraints = "']date_created':1262325600"
774 # method = 'GetSites'#request.getvalue('method') #ex : GetSites
775 # constraints = {}#request.getvalue('constraints') // nul = {}
776 # response_field = "'site_id','name','date_created'"#request.getvalue('response_field')
778 config_file = open(STATIC, "r")
779 for ligne in config_file:
780 if not ligne.startswith('#'):
781 ligne = ligne.split('\n')
782 first = ligne[0].split(';')
783 if (str(first[1]) == str(id)):
787 #Les print_method, print_option sont definis par le client (js)
788 #Les animations acceptent que les connexions anonymous
789 # args = "postmsg;animation;;;anonymous;https://www.planet-lab.eu/PLCAPI/;"
790 args = ";;"+str(save[8])+";"+str(save[9])+";anonymous;"+str(save[5])+";"+str(save[6])+";{"+str(constraints)+"};"+str(save[7])+";"
793 #Creation d'un objet event
797 "print_options": event.print_options,
798 "print_method": event.print_method,
799 "message": event.data
804 json_answer = json.dumps(cmd)
805 return HttpResponse (json_answer, mimetype="application/json")