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 user_hrn = 'ple.upmc.jordan_auge'
52 #user_hrn = 'iotlab.auge'
54 #messages.info(self.request, 'You have logged in')
55 page = Page(self.request)
58 #slice_query = Query().get('slice').filter_by('user.user_hrn', 'contains', user_hrn).select('slice_hrn')
59 slice_query = Query().get('user').filter_by('user_hrn', '==', user_hrn).select('user_hrn', 'slice.slice_hrn')
60 auth_query = Query().get('network').select('network_hrn')
61 page.enqueue_query(slice_query)
62 page.enqueue_query(auth_query)
66 slicelist = SimpleList(
69 key = 'slice.slice_hrn',
73 authlist = SimpleList(
80 context = super(DashboardView, self).get_context_data(**kwargs)
81 context['person'] = self.request.user
82 context['networks'] = authlist.render(self.request)
83 context['slices'] = slicelist.render(self.request)
85 # XXX This is repeated in all pages
86 # more general variables expected in the template
87 context['title'] = 'Test view that combines various plugins'
88 # the menu items on the top
89 context['topmenu_items'] = topmenu_items('Dashboard', self.request)
90 # so we can sho who is logged
91 context['username'] = the_user(self.request)
93 context.update(page.prelude_env())
97 class UserRegisterView(RegistrationView):
99 A registration backend which follows a simple workflow:
101 1. User signs up, inactive account is created.
103 2. Email is sent to user with activation link.
105 3. User clicks activation link, account is now active.
107 Using this backend requires that
109 * ``registration`` be listed in the ``INSTALLED_APPS`` setting
110 (since this backend makes use of models defined in this
113 * The setting ``ACCOUNT_ACTIVATION_DAYS`` be supplied, specifying
114 (as an integer) the number of days from registration during
115 which a user may activate their account (after that period
116 expires, activation will be disallowed).
118 * The creation of the templates
119 ``registration/activation_email_subject.txt`` and
120 ``registration/activation_email.txt``, which will be used for
121 the activation email. See the notes for this backends
122 ``register`` method for details regarding these templates.
124 Additionally, registration can be temporarily closed by adding the
125 setting ``REGISTRATION_OPEN`` and setting it to
126 ``False``. Omitting this setting, or setting it to ``True``, will
127 be interpreted as meaning that registration is currently open and
130 Internally, this is accomplished via storing an activation key in
131 an instance of ``registration.models.RegistrationProfile``. See
132 that model and its custom manager for full documentation of its
133 fields and supported operations.
136 form_class = UserRegisterForm
138 def register(self, request, **cleaned_data):
140 Given a username, email address and password, register a new
141 user account, which will initially be inactive.
143 Along with the new ``User`` object, a new
144 ``registration.models.RegistrationProfile`` will be created,
145 tied to that ``User``, containing the activation key which
146 will be used for this account.
148 An email will be sent to the supplied email address; this
149 email should contain an activation link. The email will be
150 rendered using two templates. See the documentation for
151 ``RegistrationProfile.send_activation_email()`` for
152 information about these templates and the contexts provided to
155 After the ``User`` and ``RegistrationProfile`` are created and
156 the activation email is sent, the signal
157 ``registration.signals.user_registered`` will be sent, with
158 the new ``User`` as the keyword argument ``user`` and the
159 class of this backend as the sender.
162 first_name = cleaned_data['first_name']
163 last_name = cleaned_data['last_name']
164 affiliation= cleaned_data['affiliation']
165 email = cleaned_data['email']
166 password = cleaned_data['password1']
168 #password2 = cleaned_data['password2']
169 keypair = cleaned_data['keypair']
171 #if Site._meta.installed:
172 # site = Site.objects.get_current()
174 # site = RequestSite(request)
177 new_user = PendingUser.objects.create_inactive_user(first_name, last_name, email, password, site)
178 signals.user_registered.send(sender=self.__class__,
183 def get_context_data(self, **kwargs):
184 context = super(UserRegisterView, self).get_context_data(**kwargs)
185 context['topmenu_items'] = topmenu_items('Register', self.request)
186 context['username'] = the_user (self.request)
189 def registration_allowed(self, request):
191 Indicate whether account registration is currently permitted,
192 based on the value of the setting ``REGISTRATION_OPEN``. This
193 is determined as follows:
195 * If ``REGISTRATION_OPEN`` is not specified in settings, or is
196 set to ``True``, registration is permitted.
198 * If ``REGISTRATION_OPEN`` is both specified and set to
199 ``False``, registration is not permitted.
202 return getattr(settings, 'REGISTRATION_OPEN', True)
204 def get_success_url(self, request, user):
206 Return the name of the URL to redirect to after successful
210 return ('user_register_complete', (), {})
213 class UserValidateView(ActivationView):
214 def activate(self, request, activation_key):
216 Given an an activation key, look up and activate the user
217 account corresponding to that key (if possible).
219 After successful activation, the signal
220 ``registration.signals.user_activated`` will be sent, with the
221 newly activated ``User`` as the keyword argument ``user`` and
222 the class of this backend as the sender.
225 activated_user = RegistrationProfile.objects.activate_user(activation_key)
227 signals.user_activated.send(sender=self.__class__,
230 return activated_user
232 def get_success_url(self, request, user):
233 return ('registration_activation_complete', (), {})
236 # DEPRECATED #from portal.portalpage import PortalPage
237 # DEPRECATED #from plugins.wizard import Wizard
238 # DEPRECATED #from plugins.form import CreateForm
239 # DEPRECATED #from plugins.raw.raw import Raw # XXX
241 # DEPRECATED #from myslice.viewutils import the_user
243 # DEPRECATED #from django.template.loader import render_to_string
244 # DEPRECATED #from django.template import RequestContext
245 # DEPRECATED #from django.views import generic
247 # DEPRECATED #from django.contrib.formtools.wizard.views import NamedUrlSessionWizardView
248 # DEPRECATED ##from django.core.files.storage import FileSystemStorage
249 # DEPRECATED #from django.core.files.storage import default_storage
251 # DEPRECATED ##class MerlinWizard(NamedUrlSessionWizardView):
256 # DEPRECATED ## @classonlymethod
257 # DEPRECATED ## def as_view(cls, *args, **kwargs):
258 # DEPRECATED ## kwargs.update({
259 # DEPRECATED ## 'form_list': [
260 # DEPRECATED ## NameForm,
261 # DEPRECATED ## QuestForm,
262 # DEPRECATED ## ColorForm,
264 # DEPRECATED ## 'url_name': 'merlin_wizard'
266 # DEPRECATED ## return super(MerlinWizard, cls).as_view(*args, **kwargs)
268 # DEPRECATED #class UserRegisterWizardView(NamedUrlSessionWizardView):
269 # DEPRECATED ##class UserRegisterWizardView(LoginRequiredMixin, NamedUrlSessionWizardView):
270 # DEPRECATED # # Notice that I specify a file storage instance. If you don't specify this,
271 # DEPRECATED # # and you need to support FileField or ImageField in your forms, you'll get
272 # DEPRECATED # # errors from Django. This is something else I think could be handled by
273 # DEPRECATED # # the views better. Seems to me that it should just use whatever the
274 # DEPRECATED # # default/specified storage is for the rest of your project/application.
275 # DEPRECATED # file_storage = default_storage # FileSystemStorage()
276 # DEPRECATED # template_name = "register_user_wizard.html"
278 # DEPRECATED # def done(self, form_list, **kwargs):
279 # DEPRECATED # step1_form = form_list[0]
280 # DEPRECATED # step2_form = form_list[1]
282 # DEPRECATED # productext = self.create_product(product_form)
283 # DEPRECATED # shippings = self.create_shippings(productext, shipping_forms)
284 # DEPRECATED # images = self.create_images(productext, image_forms)
286 # DEPRECATED # if all([productext, shippings, images]):
287 # DEPRECATED # del self.request.session["wizard_product_wizard_view"]
289 # DEPRECATED # messages.success(self.request,
290 # DEPRECATED # _("Your product has been created."))
291 # DEPRECATED # return HttpResponseRedirect(self.get_success_url(productext))
293 # DEPRECATED # messages.error(self.request, _("Something went wrong creating your "
294 # DEPRECATED # "product. Please try again or contact support."))
295 # DEPRECATED # return HttpResponseRedirect(reverse("register_wizard"))
297 # DEPRECATED # #def get_form_kwargs(self, step):
298 # DEPRECATED # # if step == "product":
299 # DEPRECATED # # return {"user": self.request.user}
300 # DEPRECATED # # return {}
302 # DEPRECATED ## The portal should hook the slice and user creation pages
304 # DEPRECATED #def register_user(request):
306 # DEPRECATED # if request.method == 'POST':
307 # DEPRECATED # form = UserRegisterForm(request.POST) # Nous reprenons les données
308 # DEPRECATED # if form.is_valid():
309 # DEPRECATED # first_name = form.cleaned_data['first_name']
310 # DEPRECATED # last_name = form.cleaned_data['last_name']
311 # DEPRECATED # email = form.cleaned_data['email']
312 # DEPRECATED # password = form.cleaned_data['password']
313 # DEPRECATED # password2 = form.cleaned_data['password2']
314 # DEPRECATED # keypair = form.cleaned_data['keypair']
315 # DEPRECATED # ## Ici nous pouvons traiter les données du formulaire
316 # DEPRECATED # #sujet = form.cleaned_data['sujet']
317 # DEPRECATED # #message = form.cleaned_data['message']
318 # DEPRECATED # #envoyeur = form.cleaned_data['envoyeur']
319 # DEPRECATED # #renvoi = form.cleaned_data['renvoi']
320 # DEPRECATED # ## Nous pourrions ici envoyer l'e-mail grâce aux données que nous venons de récupérer
321 # DEPRECATED # #envoi = True
323 # DEPRECATED # form = UserRegisterForm()
324 # DEPRECATED # return render(request, 'register_user.html', locals())
326 # DEPRECATED #def index(request):
328 # DEPRECATED # WIZARD_TITLE = 'User registration'
329 # DEPRECATED # STEP1_TITLE = 'Enter your details'
330 # DEPRECATED # STEP2_TITLE = 'Select your institution'
331 # DEPRECATED # STEP3_TITLE = 'Authentication'
332 # DEPRECATED # STEP4_TITLE = 'Request a slice (optional)'
333 # DEPRECATED # STEP5_TITLE = 'Waiting for validation'
334 # DEPRECATED # STEP6_TITLE = 'Account validated'
336 # DEPRECATED # STEP0 = render_to_string('account_validated.html', context_instance=RequestContext(request))
337 # DEPRECATED # STEP2_HTML = """
338 # DEPRECATED # coucou
340 # DEPRECATED # STEP4 = """
343 # DEPRECATED # STEP5 = render_to_string('account_validated.html', context_instance=RequestContext(request))
345 # DEPRECATED # p = PortalPage(request)
347 # DEPRECATED # # This is redundant with the Wizard title
348 # DEPRECATED # p << "<h3>User registration</h3>"
350 # DEPRECATED # sons = []
351 # DEPRECATED # start_step = 1
353 # DEPRECATED # # STEP 1
354 # DEPRECATED # # If the user already exists (is logged), let's display a summary of his account details
355 # DEPRECATED # # Otherwise propose a form to fill in
356 # DEPRECATED # if the_user(request):
357 # DEPRECATED # # Fill a disabled form with user info
358 # DEPRECATED # # Please logout to register another user
359 # DEPRECATED # sons.append(Raw(page=p, title=STEP1_TITLE, togglable=False, html=STEP0))
360 # DEPRECATED # start_step += 1
362 # DEPRECATED # # We could pass a list of fields also, instead of retrieving them from metadata
363 # DEPRECATED # # Otherwise we need some heuristics to display nice forms
364 # DEPRECATED # # XXX Could we log the user in after the form is validated ?
365 # DEPRECATED # # XXX Explain the password is for XXX
366 # DEPRECATED # field_list = [{
367 # DEPRECATED # 'name' : 'First name',
368 # DEPRECATED # 'field' : 'firstname',
369 # DEPRECATED # 'type' : 'text',
370 # DEPRECATED # 'validate_rx' : '^[a-zA-Z -]+$',
371 # DEPRECATED # 'validate_err': 'Your first name must be comprised of letters only',
372 # DEPRECATED # 'description' : 'Enter your first name',
374 # DEPRECATED # 'name' : 'Last name',
375 # DEPRECATED # 'field' : 'lastname',
376 # DEPRECATED # 'type' : 'text',
377 # DEPRECATED # 'validate_rx' : '^[a-zA-Z -]+$',
378 # DEPRECATED # 'validate_err': 'Your last name must be comprised of letters only',
379 # DEPRECATED # 'description' : 'Enter your last name',
381 # DEPRECATED # 'name' : 'Email',
382 # DEPRECATED # 'field' : 'email',
383 # DEPRECATED # 'type' : 'text',
384 # DEPRECATED # 'description' : 'Enter your email address',
386 # DEPRECATED # 'name' : 'Password',
387 # DEPRECATED # 'field' : 'password',
388 # DEPRECATED # 'type' : 'password',
389 # DEPRECATED # 'description' : 'Enter your password',
391 # DEPRECATED # 'name' : 'Confirm password',
392 # DEPRECATED # 'field' : 'password2',
393 # DEPRECATED # 'type' : 'password',
394 # DEPRECATED # 'description' : 'Enter your password again',
396 # DEPRECATED # sons.append(CreateForm(page = p, title = STEP1_TITLE, togglable = False, object = 'local:user', fields = field_list))
398 # DEPRECATED # # STEP 2
399 # DEPRECATED # # If the user already exists (is logged), let's display a summary of its institution
400 # DEPRECATED # # Otherwise propose a form to fill in (we should base our selection on the email)
401 # DEPRECATED # if the_user(request):
402 # DEPRECATED # # Fill a disabled form with institution
403 # DEPRECATED # # Please logout to register another user
404 # DEPRECATED # sons.append(Raw(page=p, title=STEP2_TITLE, togglable=False, html="User created"))
405 # DEPRECATED # start_step += 1
407 # DEPRECATED # sons.append(CreateForm(page = p, title = STEP2_TITLE, togglable = False, object = 'slice')) #institution'))
409 # DEPRECATED # # STEP3
410 # DEPRECATED # # Please should your prefered authentication method
411 # DEPRECATED # # This step should allow the user to either choose the user or managed mode in MySlice
412 # DEPRECATED # sons.append(Raw(page = p, title = STEP3_TITLE, togglable = False, html = STEP2_HTML))
414 # DEPRECATED # # Step 4: Request a slice (optional)
415 # DEPRECATED # sons.append(CreateForm(page = p, title = STEP4_TITLE, togglable = False, object = 'slice'))
417 # DEPRECATED # # Step 5: Your request is waiting for validation
418 # DEPRECATED # # Periodic refresh
419 # DEPRECATED # sons.append(Raw(page = p, title = STEP5_TITLE, togglable = False, html = STEP4))
421 # DEPRECATED # # Step 6: Account validation = welcome for newly validated users
422 # DEPRECATED # # . delegation
423 # DEPRECATED # # . platforms
424 # DEPRECATED # # . slice
425 # DEPRECATED # # . pointers
426 # DEPRECATED # sons.append(Raw(page = p, title = STEP6_TITLE, togglable = False, html = STEP5))
428 # DEPRECATED # wizard = Wizard(
429 # DEPRECATED # page = p,
430 # DEPRECATED # title = WIZARD_TITLE,
431 # DEPRECATED # togglable = False,
432 # DEPRECATED # sons = sons,
433 # DEPRECATED # start_step = start_step,
436 # DEPRECATED # p << wizard.render(request) # in portal page if possible
438 # DEPRECATED # return p.render()
441 # DEPRECATED ## view for my_account
442 # DEPRECATED # class MyAccountView(TemplateView):
443 # DEPRECATED # template_name = "my_account.html"
445 # DEPRECATED # def from_process(self, request, **cleaned_data):
446 # DEPRECATED # #if request.method == 'POST':
447 # DEPRECATED # # if request.POST['submit_name']:
448 # DEPRECATED # if 'fname' in request.POST:
449 # DEPRECATED # messsag= "Got Name"
450 # DEPRECATED # #return render(request, 'portal/my_account.html')
451 # DEPRECATED # #response = HttpResponse("Here's the text of the Web page.")
452 # DEPRECATED # return HttpResponse(message)
454 # DEPRECATED # def get_context_data(self, **kwargs):
455 # DEPRECATED # page = Page(self.request)
456 # DEPRECATED # context = super(MyAccountView, self).get_context_data(**kwargs)
457 # DEPRECATED # context['person'] = self.request.user
458 # DEPRECATED # # XXX This is repeated in all pages
459 # DEPRECATED # # more general variables expected in the template
460 # DEPRECATED # context['title'] = 'User Profile Page'
461 # DEPRECATED # # the menu items on the top
462 # DEPRECATED # context['topmenu_items'] = topmenu_items('my_account', self.request)
463 # DEPRECATED # # so we can sho who is logged
464 # DEPRECATED # context['username'] = the_user(self.request)
465 # DEPRECATED # context.update(page.prelude_env())
466 # DEPRECATED # return context
470 # View for my_account form
471 def my_account(request):
472 return render(request, 'my_account.html')
474 #my_acc form value processing
475 def acc_process(request):
476 # getting the user_id from the session [now hardcoded]
477 get_user = PendingUser.objects.get(id='1') # here we will get the id/email from session e.g., person.email
478 if 'submit_name' in request.POST:
479 edited_first_name = request.POST['fname']
480 edited_last_name = request.POST['lname']
481 #email = 'test_email@gmail.com'
482 #password = 'test_pp'
483 #message = 'F_Name: %s L_name: %s dummy_pp: %s' % (first_name, last_name, password)
486 # insert into DB [needed for registration page]
487 #approach borrowed from register view
488 #new_user = PendingUser.objects.create_inactive_user(edited_first_name, edited_last_name, email, password, site)
489 #conventional approach
490 #b = PendingUser(first_name=edited_first_name, edited_last_name=last_name)
493 # select and update [will be used throughout this view]
494 # select the logged in user [for the moment hard coded]
495 #get_user = PendingUser.objects.get(id='1') # here we will get the id/email from session e.g., person.email
496 # update first and last name
497 get_user.first_name = edited_first_name
498 get_user.last_name = edited_last_name
501 return HttpResponse('Success: Name Updated!!')
502 elif 'submit_pass' in request.POST:
503 edited_password = request.POST['password']
504 # select the logged in user [for the moment hard coded]
505 #get_user = PendingUser.objects.get(id='1') # here we will get the id/email from session e.g., person.email
507 get_user.password = edited_password
509 return HttpResponse('Success: Password Changed!!')
510 elif 'generate' in request.POST:
512 from M2Crypto import Rand, RSA, BIO
516 def blank_callback():
517 "Replace the default dashes"
521 Rand.rand_seed (os.urandom (KEY_LENGTH))
523 key = RSA.gen_key (KEY_LENGTH, 65537, blank_callback)
524 # Create memory buffers
525 pri_mem = BIO.MemoryBuffer()
526 pub_mem = BIO.MemoryBuffer()
527 # Save keys to buffers
528 key.save_key_bio(pri_mem, None)
529 key.save_pub_key_bio(pub_mem)
532 public_key = pub_mem.getvalue()
533 private_key = pri_mem.getvalue()
535 keypair = '{"user_public_key":"'+ public_key + '", "user_private_key":"'+ private_key + '"}'
536 #keypair = re.sub("\r", "", keypair)
537 #keypair = re.sub("\n", "\\n", keypair)
538 keypair = keypair.rstrip('\r\n')
539 get_user.keypair = keypair
541 return HttpResponse('Success: New Keypair Generated! %s' % keypair)
543 elif 'upload_key' in request.POST:
544 up_file = request.FILES['pubkey']
545 file_content = up_file.read()
546 file_name = up_file.name
547 file_extension = os.path.splitext(file_name)[1]
548 allowed_extension = ['.pub','.txt']
549 if file_extension in allowed_extension:
550 file_content = '{"user_public_key":"'+ file_content +'"}'
551 file_content = re.sub("\r", "", file_content)
552 file_content = re.sub("\n", "\\n",file_content)
553 get_user.keypair = file_content
555 return HttpResponse('Success: Publickey uploaded! Old records overwritten')
557 return HttpResponse('Please upload a valid public key.')
560 message = 'You submitted an empty form.'
561 return HttpResponse(message)
565 # view for contact form
566 def contact(request):
567 if request.method == 'POST': # If the form has been submitted...
568 form = ContactForm(request.POST) # A form bound to the POST data
569 if form.is_valid(): # All validation rules pass
570 # Process the data in form.cleaned_data
571 first_name = form.cleaned_data['first_name']
572 last_name = form.cleaned_data['last_name']
573 affiliation = form.cleaned_data['affiliation']
574 subject = form.cleaned_data['subject']
575 message = form.cleaned_data['message']
576 email = form.cleaned_data['email'] # email of the sender
577 cc_myself = form.cleaned_data['cc_myself']
579 recipients = ['yasin.upmc@gmail.com']
581 recipients.append(email)
583 from django.core.mail import send_mail
584 send_mail("Onelab user submitted a query ", [first_name,last_name,affiliation,subject,message], email, recipients)
585 return render(request,'contact_sent.html') # Redirect after POST
587 form = ContactForm() # An unbound form
589 return render(request, 'contact.html', {
594 def slice_request(request):
595 if request.method == 'POST': # If the form has been submitted...
596 form = SliceRequestForm(request.POST) # A form bound to the POST data
597 if form.is_valid(): # All validation rules pass
598 # Process the data in form.cleaned_data
599 slice_name = form.cleaned_data['slice_name']
600 number_of_nodes = form.cleaned_data['number_of_nodes']
601 type_of_nodes = form.cleaned_data['type_of_nodes']
602 purpose = form.cleaned_data['purpose']
603 email = form.cleaned_data['email'] # email of the sender
604 cc_myself = form.cleaned_data['cc_myself']
606 recipients = ['yasin.upmc@gmail.com','jordan.auge@lip6.fr']
608 recipients.append(email)
610 from django.core.mail import send_mail
611 send_mail("Onelab New Slice request form submitted", [slice_name,number_of_nodes,type_of_nodes,purpose], email, recipients)
612 return render(request,'slicereq_recvd.html') # Redirect after POST
614 form = SliceRequestForm() # An unbound form
617 # template_env['form'] = form
618 # template_env['topmenu_items'] = topmenu_items('Request a slice', request)
619 # template_env['unfold1_main'] = render(request, 'slice_request_.html', {
622 # from django.shortcuts import render_to_response
623 # from django.template import RequestContext
624 # return render_to_response ('view-unfold1.html',template_env,
625 # context_instance=RequestContext(request))
627 return render(request, 'slice_request.html', {
629 'topmenu_items': topmenu_items('Request a slice', request),
630 'username': the_user (request)
634 class PresViewView(TemplateView):
635 template_name = "view-unfold1.html"
637 def get_context_data(self, **kwargs):
639 page = Page(self.request)
641 pres_view = PresView(page = page)
643 context = super(PresViewView, self).get_context_data(**kwargs)
645 #context['ALL_STATIC'] = "all_static"
646 context['unfold1_main'] = pres_view.render(self.request)
648 # XXX This is repeated in all pages
649 # more general variables expected in the template
650 context['title'] = 'Test view that combines various plugins'
651 # the menu items on the top
652 context['topmenu_items'] = topmenu_items('PresView', self.request)
653 # so we can sho who is logged
654 context['username'] = the_user(self.request)
656 prelude_env = page.prelude_env()
657 context.update(prelude_env)
661 def json_me(config_file,type):
663 for ligne in config_file:
664 if not ligne.startswith('#'):
665 args = ligne.split(';')
666 json_answer += str('{ "name": "' + args[0] + '" ,"id":"' + args[1] + '" ,"descriptif":"' + args[2]+'"')
668 json_answer += str(',"contraints":')
670 json_answer += str('""')
672 json_answer += str(args[3])
673 json_answer += str('},')
674 return json_answer[:-1]
677 DIR = '/var/myslice/'
678 STATIC = '%s/config_method_static' % DIR
679 DYNAMIC = '%s/config_method_dynamic' % DIR
680 ANIMATION = '%s/config_method_animation' % DIR
682 def pres_view_methods(request, type):
686 elif type =="static":
687 config = open(STATIC, "r")
688 json_answer = str('{ "options": [')
689 json_answer += str(json_me(config,"static"))
690 json_answer += str('] }')
692 elif type =="dynamic":
693 config = open(DYNAMIC, "r")
694 json_answer = str('{ "options": [')
695 json_answer += str(json_me(config,"dynamic"))
696 json_answer += str('] }')
698 elif type =="animation":
699 config = open(ANIMATION, "r")
700 json_answer = str('{ "options": [')
701 json_answer += str(json_me(config,"animation"))
702 json_answer += str('] }')
705 config = open(STATIC, "r")
706 json_answer = str('{ "static": [')
707 json_answer += str(json_me(config,"static"))
708 json_answer += str('],')
709 json_answer += str('"dynamic": [')
711 config = open(DYNAMIC, "r")
712 json_answer += str(json_me(config,"dynamic"))
713 json_answer += str('],')
714 json_answer += str('"animation": [')
716 config = open(ANIMATION, "r")
717 json_answer += str(json_me(config,"animation"))
718 json_answer += str('] }')
722 return HttpResponse (json_answer, mimetype="application/json")
724 def pres_view_animation(request, constraints, id):
726 # sites crees depuis 2008
727 # static.py?contraints=']date_created':1262325600&id='name_id"'
729 # method = request.getvalue('method') #ex : GetSites
730 #constraints = "']date_created':1262325600"
736 # method = 'GetSites'#request.getvalue('method') #ex : GetSites
737 # constraints = {}#request.getvalue('constraints') // nul = {}
738 # response_field = "'site_id','name','date_created'"#request.getvalue('response_field')
740 config_file = open(ANIMATION, "r")
741 for ligne in config_file:
742 if not ligne.startswith('#'):
743 ligne = ligne.split('\n')
744 first = ligne[0].split(';')
745 if (str(first[1]) == str(id)):
749 #Les print_method, print_option sont definis par le client (js)
750 #Les animations acceptent que les connexions anonymous
751 # args = "postmsg;animation;;;anonymous;https://www.planet-lab.eu/PLCAPI/;"
752 args = ";;"+str(save[8])+";"+str(save[9])+";anonymous;"+str(save[5])+";"+str(save[6])+";{"+str(constraints)+"};"+str(save[7])+";"
755 #Creation d'un objet event
759 "print_options": event.print_options,
760 "print_method": event.print_method,
761 "message": event.data
766 json_answer = json.dumps(cmd)
767 return HttpResponse (json_answer, mimetype="application/json")
769 def pres_view_static(request, constraints, id):
770 #constraints = "']date_created':1262325600"
773 # method = 'GetSites'#request.getvalue('method') #ex : GetSites
774 # constraints = {}#request.getvalue('constraints') // nul = {}
775 # response_field = "'site_id','name','date_created'"#request.getvalue('response_field')
777 config_file = open(STATIC, "r")
778 for ligne in config_file:
779 if not ligne.startswith('#'):
780 ligne = ligne.split('\n')
781 first = ligne[0].split(';')
782 if (str(first[1]) == str(id)):
786 #Les print_method, print_option sont definis par le client (js)
787 #Les animations acceptent que les connexions anonymous
788 # args = "postmsg;animation;;;anonymous;https://www.planet-lab.eu/PLCAPI/;"
789 args = ";;"+str(save[8])+";"+str(save[9])+";anonymous;"+str(save[5])+";"+str(save[6])+";{"+str(constraints)+"};"+str(save[7])+";"
792 #Creation d'un objet event
796 "print_options": event.print_options,
797 "print_method": event.print_method,
798 "message": event.data
803 json_answer = json.dumps(cmd)
804 return HttpResponse (json_answer, mimetype="application/json")