portal/views.py

   1 # -*- coding: utf-8 -*-
   2 #
   3 # portal/views.py: views for the portal application
   4 # This file is part of the Manifold project.
   5 #
   6 # Authors:
   7 #   Jordan Augé <jordan.auge@lip6.fr>
   8 #   Mohammed Yasin Rahman <mohammed-yasin.rahman@lip6.fr>
   9 # Copyright 2013, UPMC Sorbonne Universités / LIP6
  10 #
  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.
  14 #
  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
  18 # details.
  19 #
  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.
  23
  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
  30 from django.template.loader      import render_to_string
  31 from django.core.mail            import send_mail
  32 from django.utils.decorators     import method_decorator
  33 from django.contrib.auth.decorators import login_required
  34
  35 from plugins.lists.simplelist    import SimpleList
  36 from plugins.hazelnut            import Hazelnut
  37 from plugins.pres_view           import PresView
  38 from portal.event import Event
  39 import json
  40
  41 from portal                      import signals
  42 from portal.forms                import SliceRequestForm, ContactForm
  43 from portal.util                 import RegistrationView, ActivationView
  44 from portal.models               import PendingUser, PendingSlice
  45 from portal.actions              import authority_get_pi_emails, get_request_by_authority
  46 from manifold.core.query         import Query
  47 from manifold.manifoldapi        import execute_query
  48 from unfold.page                 import Page
  49 from myslice.viewutils           import topmenu_items, the_user
  50 from django.http                 import HttpResponseRedirect, HttpResponse
  51
  52 from M2Crypto                    import Rand, RSA, BIO
  53 import os, re
  54
  55 class DashboardView(TemplateView):
  56     template_name = "dashboard.html"
  57
  58     #This view requires login
  59     @method_decorator(login_required)
  60     def dispatch(self, *args, **kwargs):
  61         return super(DashboardView, self).dispatch(*args, **kwargs)
  62
  63     def get_context_data(self, **kwargs):
  64         # We might have slices on different registries with different user accounts
  65         # 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
  66         # Different registries mean different identities, unless we identify via SFA HRN or have associated the user email to a single hrn
  67
  68         #messages.info(self.request, 'You have logged in')
  69         page = Page(self.request)
  70
  71         # Slow...
  72         #slice_query = Query().get('slice').filter_by('user.user_hrn', 'contains', user_hrn).select('slice_hrn')
  73         slice_query = Query().get('user').filter_by('user_hrn', '==', '$user_hrn').select('user_hrn', 'slice.slice_hrn')
  74         auth_query  = Query().get('network').select('network_hrn')
  75         print "AUTH QUERY =====================", auth_query
  76         print "filter", auth_query.filters
  77         page.enqueue_query(slice_query)
  78         page.enqueue_query(auth_query)
  79
  80         page.expose_js_metadata()
  81         page.expose_queries()
  82
  83         slicelist = SimpleList(
  84             title = None,
  85             page  = page,
  86             key   = 'slice.slice_hrn',
  87             query = slice_query,
  88         )
  89
  90         authlist = SimpleList(
  91             title = None,
  92             page  = page,
  93             key   = 'network_hrn',
  94             query = auth_query,
  95         )
  96
  97         context = super(DashboardView, self).get_context_data(**kwargs)
  98         context['person']   = self.request.user
  99         context['networks'] = authlist.render(self.request)
 100         context['slices']   = slicelist.render(self.request)
 101
 102         # XXX This is repeated in all pages
 103         # more general variables expected in the template
 104         context['title'] = 'Test view that combines various plugins'
 105         # the menu items on the top
 106         context['topmenu_items'] = topmenu_items('Dashboard', self.request)
 107         # so we can sho who is logged
 108         context['username'] = the_user(self.request)
 109
 110         context.update(page.prelude_env())
 111
 112         return context
 113
 114 # DEPRECATED #class UserRegisterView(RegistrationView):
 115 # DEPRECATED #    """
 116 # DEPRECATED #    A registration backend which follows a simple workflow:
 117 # DEPRECATED #
 118 # DEPRECATED #    1. User signs up, inactive account is created.
 119 # DEPRECATED #
 120 # DEPRECATED #    2. Email is sent to user with activation link.
 121 # DEPRECATED #
 122 # DEPRECATED #    3. User clicks activation link, account is now active.
 123 # DEPRECATED #
 124 # DEPRECATED #    Using this backend requires that
 125 # DEPRECATED #
 126 # DEPRECATED #    * ``registration`` be listed in the ``INSTALLED_APPS`` setting
 127 # DEPRECATED #      (since this backend makes use of models defined in this
 128 # DEPRECATED #      application).
 129 # DEPRECATED #
 130 # DEPRECATED #    * The setting ``ACCOUNT_ACTIVATION_DAYS`` be supplied, specifying
 131 # DEPRECATED #      (as an integer) the number of days from registration during
 132 # DEPRECATED #      which a user may activate their account (after that period
 133 # DEPRECATED #      expires, activation will be disallowed).
 134 # DEPRECATED #
 135 # DEPRECATED #    * The creation of the templates
 136 # DEPRECATED #      ``registration/activation_email_subject.txt`` and
 137 # DEPRECATED #      ``registration/activation_email.txt``, which will be used for
 138 # DEPRECATED #      the activation email. See the notes for this backends
 139 # DEPRECATED #      ``register`` method for details regarding these templates.
 140 # DEPRECATED #
 141 # DEPRECATED #    Additionally, registration can be temporarily closed by adding the
 142 # DEPRECATED #    setting ``REGISTRATION_OPEN`` and setting it to
 143 # DEPRECATED #    ``False``. Omitting this setting, or setting it to ``True``, will
 144 # DEPRECATED #    be interpreted as meaning that registration is currently open and
 145 # DEPRECATED #    permitt ed.
 146 # DEPRECATED #
 147 # DEPRECATED #    Internally, this is accomplished via storing an activation key in
 148 # DEPRECATED #    an instance of ``registration.models.RegistrationProfile``. See
 149 # DEPRECATED #    that model and its custom manager for full documentation of its
 150 # DEPRECATED #    fields and supported operations.
 151 # DEPRECATED #
 152 # DEPRECATED #    """
 153 # DEPRECATED ## DEPRECATED #    form_class = UserRegisterForm
 154 # DEPRECATED #
 155 # DEPRECATED #    def register(self, request, **cleaned_data):
 156 # DEPRECATED #        """
 157 # DEPRECATED #        Given a username, email address and password, register a new
 158 # DEPRECATED #        user account, which will initially be inactive.
 159 # DEPRECATED #
 160 # DEPRECATED #        Along with the new ``User`` object, a new
 161 # DEPRECATED #        ``registration.models.RegistrationProfile`` will be created,
 162 # DEPRECATED #        tied to that ``User``, containing the activation key which
 163 # DEPRECATED #        will be used for this account.
 164 # DEPRECATED #
 165 # DEPRECATED #        An email will be sent to the supplied email address; this
 166 # DEPRECATED #        email should contain an activation link. The email will be
 167 # DEPRECATED #        rendered using two templates. See the documentation for
 168 # DEPRECATED #        ``RegistrationProfile.send_activation_email()`` for
 169 # DEPRECATED #        information about these templates and the contexts provided to
 170 # DEPRECATED #        them.
 171 # DEPRECATED #
 172 # DEPRECATED #        After the ``User`` and ``RegistrationProfile`` are created and
 173 # DEPRECATED #        the activation email is sent, the signal
 174 # DEPRECATED #        ``registration.signals.user_registered`` will be sent, with
 175 # DEPRECATED #        the new ``User`` as the keyword argument ``user`` and the
 176 # DEPRECATED #        class of this backend as the sender.
 177 # DEPRECATED #
 178 # DEPRECATED #        """
 179 # DEPRECATED #        first_name = cleaned_data['first_name']
 180 # DEPRECATED #        last_name  = cleaned_data['last_name']
 181 # DEPRECATED #        affiliation= cleaned_data['affiliation']
 182 # DEPRECATED #        email      = cleaned_data['email']
 183 # DEPRECATED #        password   = cleaned_data['password1']
 184 # DEPRECATED #
 185 # DEPRECATED #        #password2  = cleaned_data['password2']
 186 # DEPRECATED #        keypair    = cleaned_data['keypair']
 187 # DEPRECATED #
 188 # DEPRECATED #        #if Site._meta.installed:
 189 # DEPRECATED #        #    site = Site.objects.get_current()
 190 # DEPRECATED #        #else:
 191 # DEPRECATED #        #    site = RequestSite(request)
 192 # DEPRECATED #        site = None
 193 # DEPRECATED #
 194 # DEPRECATED #        new_user = PendingUser.objects.create_inactive_user(first_name, last_name, email, password, site)
 195 # DEPRECATED #        signals.user_registered.send(sender=self.__class__,
 196 # DEPRECATED #                                     user=new_user,
 197 # DEPRECATED #                                     request=request)
 198 # DEPRECATED #        return new_user
 199 # DEPRECATED #
 200 # DEPRECATED #    def get_context_data(self, **kwargs):
 201 # DEPRECATED #        context = super(UserRegisterView, self).get_context_data(**kwargs)
 202 # DEPRECATED #        context['topmenu_items'] = topmenu_items('Register', self.request)
 203 # DEPRECATED #        context['username'] = the_user (self.request)
 204 # DEPRECATED #        return context
 205 # DEPRECATED #
 206 # DEPRECATED #    def registration_allowed(self, request):
 207 # DEPRECATED #        """
 208 # DEPRECATED #        Indicate whether account registration is currently permitted,
 209 # DEPRECATED #        based on the value of the setting ``REGISTRATION_OPEN``. This
 210 # DEPRECATED #        is determined as follows:
 211 # DEPRECATED #
 212 # DEPRECATED #        * If ``REGISTRATION_OPEN`` is not specified in settings, or is
 213 # DEPRECATED #          set to ``True``, registration is permitted.
 214 # DEPRECATED #
 215 # DEPRECATED #        * If ``REGISTRATION_OPEN`` is both specified and set to
 216 # DEPRECATED #          ``False``, registration is not permitted.
 217 # DEPRECATED #
 218 # DEPRECATED #        """
 219 # DEPRECATED #        return getattr(settings, 'REGISTRATION_OPEN', True)
 220 # DEPRECATED #
 221 # DEPRECATED #    def get_success_url(self, request, user):
 222 # DEPRECATED #        """
 223 # DEPRECATED #        Return the name of the URL to redirect to after successful
 224 # DEPRECATED #        user registration.
 225 # DEPRECATED #
 226 # DEPRECATED #        """
 227 # DEPRECATED #        return ('user_register_complete', (), {})
 228 # DEPRECATED #
 229 # DEPRECATED #
 230 # DEPRECATED #class UserValidateView(ActivationView):
 231 # DEPRECATED #    def activate(self, request, activation_key):
 232 # DEPRECATED #        """
 233 # DEPRECATED #        Given an an activation key, look up and activate the user
 234 # DEPRECATED #        account corresponding to that key (if possible).
 235 # DEPRECATED #
 236 # DEPRECATED #        After successful activation, the signal
 237 # DEPRECATED #        ``registration.signals.user_activated`` will be sent, with the
 238 # DEPRECATED #        newly activated ``User`` as the keyword argument ``user`` and
 239 # DEPRECATED #        the class of this backend as the sender.
 240 # DEPRECATED #
 241 # DEPRECATED #        """
 242 # DEPRECATED #        activated_user = RegistrationProfile.objects.activate_user(activation_key)
 243 # DEPRECATED #        if activated_user:
 244 # DEPRECATED #            signals.user_activated.send(sender=self.__class__,
 245 # DEPRECATED #                                        user=activated_user,
 246 # DEPRECATED #                                        request=request)
 247 # DEPRECATED #        return activated_user
 248 # DEPRECATED #
 249 # DEPRECATED #    def get_success_url(self, request, user):
 250 # DEPRECATED #        return ('registration_activation_complete', (), {})
 251 # DEPRECATED #
 252 # DEPRECATED #
 253 # DEPRECATED #from portal.portalpage  import PortalPage
 254 # DEPRECATED #from plugins.wizard     import Wizard
 255 # DEPRECATED #from plugins.form       import CreateForm
 256 # DEPRECATED #from plugins.raw.raw    import Raw          # XXX
 257 # DEPRECATED #
 258 # DEPRECATED #from myslice.viewutils  import the_user
 259 # DEPRECATED #
 260 # DEPRECATED #from django.template.loader import render_to_string
 261 # DEPRECATED #from django.template import RequestContext
 262 # DEPRECATED #from django.views import generic
 263 # DEPRECATED #
 264 # DEPRECATED #from django.contrib.formtools.wizard.views import NamedUrlSessionWizardView
 265 # DEPRECATED ##from django.core.files.storage import FileSystemStorage
 266 # DEPRECATED #from django.core.files.storage import default_storage
 267 # DEPRECATED #
 268 # DEPRECATED ##class MerlinWizard(NamedUrlSessionWizardView):
 269 # DEPRECATED ##
 270 # DEPRECATED ##    ...
 271 # DEPRECATED ##    ...
 272 # DEPRECATED ##
 273 # DEPRECATED ##    @classonlymethod
 274 # DEPRECATED ##    def as_view(cls, *args, **kwargs):
 275 # DEPRECATED ##        kwargs.update({
 276 # DEPRECATED ##            'form_list': [
 277 # DEPRECATED ##                NameForm,
 278 # DEPRECATED ##                QuestForm,
 279 # DEPRECATED ##                ColorForm,
 280 # DEPRECATED ##            ],
 281 # DEPRECATED ##            'url_name': 'merlin_wizard'
 282 # DEPRECATED ##        })
 283 # DEPRECATED ##        return super(MerlinWizard, cls).as_view(*args, **kwargs)
 284 # DEPRECATED #
 285 # DEPRECATED #class UserRegisterWizardView(NamedUrlSessionWizardView):
 286 # DEPRECATED ##class UserRegisterWizardView(LoginRequiredMixin, NamedUrlSessionWizardView):
 287 # DEPRECATED #    # Notice that I specify a file storage instance. If you don't specify this,
 288 # DEPRECATED #    # and you need to support FileField or ImageField in your forms, you'll get
 289 # DEPRECATED #    # errors from Django. This is something else I think could be handled by
 290 # DEPRECATED #    # the views better. Seems to me that it should just use whatever the
 291 # DEPRECATED #    # default/specified storage is for the rest of your project/application.
 292 # DEPRECATED #    file_storage = default_storage # FileSystemStorage()
 293 # DEPRECATED #    template_name = "register_user_wizard.html"
 294 # DEPRECATED #
 295 # DEPRECATED #    def done(self, form_list, **kwargs):
 296 # DEPRECATED #        step1_form = form_list[0]
 297 # DEPRECATED #        step2_form = form_list[1]
 298 # DEPRECATED #
 299 # DEPRECATED #        productext = self.create_product(product_form)
 300 # DEPRECATED #        shippings = self.create_shippings(productext, shipping_forms)
 301 # DEPRECATED #        images = self.create_images(productext, image_forms)
 302 # DEPRECATED #
 303 # DEPRECATED #        if all([productext, shippings, images]):
 304 # DEPRECATED #            del self.request.session["wizard_product_wizard_view"]
 305 # DEPRECATED #
 306 # DEPRECATED #            messages.success(self.request,
 307 # DEPRECATED #                _("Your product has been created."))
 308 # DEPRECATED #            return HttpResponseRedirect(self.get_success_url(productext))
 309 # DEPRECATED #
 310 # DEPRECATED #        messages.error(self.request, _("Something went wrong creating your "
 311 # DEPRECATED #            "product. Please try again or contact support."))
 312 # DEPRECATED #        return HttpResponseRedirect(reverse("register_wizard"))
 313 # DEPRECATED #
 314 # DEPRECATED #    #def get_form_kwargs(self, step):
 315 # DEPRECATED #    #    if step == "product":
 316 # DEPRECATED #    #        return {"user": self.request.user}
 317 # DEPRECATED #    #    return {}
 318 # DEPRECATED #
 319 # DEPRECATED ## The portal should hook the slice and user creation pages
 320 # DEPRECATED #
 321 # DEPRECATED #def register_user(request):
 322 # DEPRECATED #
 323 # DEPRECATED #    if request.method == 'POST':
 324 # DEPRECATED #        form = UserRegisterForm(request.POST) # Nous reprenons les données
 325 # DEPRECATED #        if form.is_valid():
 326 # DEPRECATED #            first_name = form.cleaned_data['first_name']
 327 # DEPRECATED #            last_name  = form.cleaned_data['last_name']
 328 # DEPRECATED #            email      = form.cleaned_data['email']
 329 # DEPRECATED #            password   = form.cleaned_data['password']
 330 # DEPRECATED #            password2  = form.cleaned_data['password2']
 331 # DEPRECATED #            keypair    = form.cleaned_data['keypair']
 332 # DEPRECATED #            ## Ici nous pouvons traiter les données du formulaire
 333 # DEPRECATED #            #sujet = form.cleaned_data['sujet']
 334 # DEPRECATED #            #message = form.cleaned_data['message']
 335 # DEPRECATED #            #envoyeur = form.cleaned_data['envoyeur']
 336 # DEPRECATED #            #renvoi = form.cleaned_data['renvoi']
 337 # DEPRECATED #            ## Nous pourrions ici envoyer l'e-mail grâce aux données que nous venons de récupérer
 338 # DEPRECATED #            #envoi = True
 339 # DEPRECATED #    else:
 340 # DEPRECATED #        form = UserRegisterForm()
 341 # DEPRECATED #    return render(request, 'register_user.html', locals())
 342 # DEPRECATED #
 343 # DEPRECATED #def index(request):
 344 # DEPRECATED #
 345 # DEPRECATED #    WIZARD_TITLE = 'User registration'
 346 # DEPRECATED #    STEP1_TITLE  = 'Enter your details'
 347 # DEPRECATED #    STEP2_TITLE  = 'Select your institution'
 348 # DEPRECATED #    STEP3_TITLE  = 'Authentication'
 349 # DEPRECATED #    STEP4_TITLE  = 'Request a slice (optional)'
 350 # DEPRECATED #    STEP5_TITLE  = 'Waiting for validation'
 351 # DEPRECATED #    STEP6_TITLE  = 'Account validated'
 352 # DEPRECATED #
 353 # DEPRECATED #    STEP0 = render_to_string('account_validated.html', context_instance=RequestContext(request))
 354 # DEPRECATED #    STEP2_HTML   = """
 355 # DEPRECATED #    coucou
 356 # DEPRECATED #    """
 357 # DEPRECATED #    STEP4 = """
 358 # DEPRECATED #    mede
 359 # DEPRECATED #    """
 360 # DEPRECATED #    STEP5 = render_to_string('account_validated.html', context_instance=RequestContext(request))
 361 # DEPRECATED #
 362 # DEPRECATED #    p = PortalPage(request)
 363 # DEPRECATED #
 364 # DEPRECATED #    # This is redundant with the Wizard title
 365 # DEPRECATED #    p << "<h3>User registration</h3>"
 366 # DEPRECATED #
 367 # DEPRECATED #    sons = []
 368 # DEPRECATED #    start_step = 1
 369 # DEPRECATED #
 370 # DEPRECATED #    # STEP 1
 371 # DEPRECATED #    # If the user already exists (is logged), let's display a summary of his account details
 372 # DEPRECATED #    # Otherwise propose a form to fill in
 373 # DEPRECATED #    if the_user(request):
 374 # DEPRECATED #        # Fill a disabled form with user info
 375 # DEPRECATED #        # Please logout to register another user
 376 # DEPRECATED #        sons.append(Raw(page=p, title=STEP1_TITLE, togglable=False, html=STEP0))
 377 # DEPRECATED #        start_step += 1
 378 # DEPRECATED #    else:
 379 # DEPRECATED #        # We could pass a list of fields also, instead of retrieving them from metadata
 380 # DEPRECATED #        # Otherwise we need some heuristics to display nice forms
 381 # DEPRECATED #        # XXX Could we log the user in after the form is validated ?
 382 # DEPRECATED #        # XXX Explain the password is for XXX
 383 # DEPRECATED #        field_list = [{
 384 # DEPRECATED #            'name'        : 'First name',
 385 # DEPRECATED #            'field'       : 'firstname',
 386 # DEPRECATED #            'type'        : 'text',
 387 # DEPRECATED #            'validate_rx' : '^[a-zA-Z -]+$',
 388 # DEPRECATED #            'validate_err': 'Your first name must be comprised of letters only',
 389 # DEPRECATED #            'description' : 'Enter your first name',
 390 # DEPRECATED #        }, {
 391 # DEPRECATED #            'name'        : 'Last name',
 392 # DEPRECATED #            'field'       : 'lastname',
 393 # DEPRECATED #            'type'        : 'text',
 394 # DEPRECATED #            'validate_rx' : '^[a-zA-Z -]+$',
 395 # DEPRECATED #            'validate_err': 'Your last name must be comprised of letters only',
 396 # DEPRECATED #            'description' : 'Enter your last name',
 397 # DEPRECATED #        }, {
 398 # DEPRECATED #            'name'        : 'Email',
 399 # DEPRECATED #            'field'       : 'email',
 400 # DEPRECATED #            'type'        : 'text',
 401 # DEPRECATED #            'description' : 'Enter your email address',
 402 # DEPRECATED #        }, {
 403 # DEPRECATED #            'name'        : 'Password',
 404 # DEPRECATED #            'field'       : 'password',
 405 # DEPRECATED #            'type'        : 'password',
 406 # DEPRECATED #            'description' : 'Enter your password',
 407 # DEPRECATED #        }, {
 408 # DEPRECATED #            'name'        : 'Confirm password',
 409 # DEPRECATED #            'field'       : 'password2',
 410 # DEPRECATED #            'type'        : 'password',
 411 # DEPRECATED #            'description' : 'Enter your password again',
 412 # DEPRECATED #        }]
 413 # DEPRECATED #        sons.append(CreateForm(page = p, title = STEP1_TITLE, togglable = False, object = 'local:user', fields = field_list))
 414 # DEPRECATED #
 415 # DEPRECATED #    # STEP 2
 416 # DEPRECATED #    # If the user already exists (is logged), let's display a summary of its institution
 417 # DEPRECATED #    # Otherwise propose a form to fill in (we should base our selection on the email)
 418 # DEPRECATED #    if the_user(request):
 419 # DEPRECATED #        # Fill a disabled form with institution
 420 # DEPRECATED #        # Please logout to register another user
 421 # DEPRECATED #        sons.append(Raw(page=p, title=STEP2_TITLE, togglable=False, html="User created"))
 422 # DEPRECATED #        start_step += 1
 423 # DEPRECATED #    else:
 424 # DEPRECATED #        sons.append(CreateForm(page = p, title = STEP2_TITLE, togglable = False, object = 'slice')) #institution'))
 425 # DEPRECATED #
 426 # DEPRECATED #    # STEP3
 427 # DEPRECATED #    # Please should your prefered authentication method
 428 # DEPRECATED #    # This step should allow the user to either choose the user or managed mode in MySlice
 429 # DEPRECATED #    sons.append(Raw(page = p, title = STEP3_TITLE, togglable = False, html = STEP2_HTML))
 430 # DEPRECATED #
 431 # DEPRECATED #    # Step 4: Request a slice (optional)
 432 # DEPRECATED #    sons.append(CreateForm(page = p, title = STEP4_TITLE, togglable = False, object = 'slice'))
 433 # DEPRECATED #
 434 # DEPRECATED #    # Step 5: Your request is waiting for validation
 435 # DEPRECATED #    # Periodic refresh
 436 # DEPRECATED #    sons.append(Raw(page = p, title = STEP5_TITLE, togglable = False, html = STEP4))
 437 # DEPRECATED #
 438 # DEPRECATED #    # Step 6: Account validation  = welcome for newly validated users
 439 # DEPRECATED #    # . delegation
 440 # DEPRECATED #    # . platforms
 441 # DEPRECATED #    # . slice
 442 # DEPRECATED #    # . pointers
 443 # DEPRECATED #    sons.append(Raw(page = p, title = STEP6_TITLE, togglable = False, html = STEP5))
 444 # DEPRECATED #
 445 # DEPRECATED #    wizard = Wizard(
 446 # DEPRECATED #        page       = p,
 447 # DEPRECATED #        title      = WIZARD_TITLE,
 448 # DEPRECATED #        togglable  = False,
 449 # DEPRECATED #        sons       = sons,
 450 # DEPRECATED #        start_step = start_step,
 451 # DEPRECATED #    )
 452 # DEPRECATED #
 453 # DEPRECATED #    p << wizard.render(request) # in portal page if possible
 454 # DEPRECATED #
 455 # DEPRECATED #    return p.render()
 456
 457
 458 # DEPRECATED ## view for my_account
 459 # DEPRECATED # class MyAccountView(TemplateView):
 460 # DEPRECATED #    template_name = "my_account.html"
 461 # DEPRECATED #
 462 # DEPRECATED #    def from_process(self, request, **cleaned_data):
 463 # DEPRECATED #        #if request.method == 'POST':
 464 # DEPRECATED #         #       if request.POST['submit_name']:
 465 # DEPRECATED #        if 'fname' in request.POST:
 466 # DEPRECATED #                messsag= "Got Name"
 467 # DEPRECATED #                #return render(request, 'portal/my_account.html')
 468 # DEPRECATED #                #response = HttpResponse("Here's the text of the Web page.")
 469 # DEPRECATED #                return HttpResponse(message)
 470 # DEPRECATED #
 471 # DEPRECATED #    def get_context_data(self, **kwargs):
 472 # DEPRECATED #        page = Page(self.request)
 473 # DEPRECATED #        context = super(MyAccountView, self).get_context_data(**kwargs)
 474 # DEPRECATED #        context['person']   = self.request.user
 475 # DEPRECATED #        # XXX This is repeated in all pages
 476 # DEPRECATED #        # more general variables expected in the template
 477 # DEPRECATED #        context['title'] = 'User Profile Page'
 478 # DEPRECATED #        # the menu items on the top
 479 # DEPRECATED #        context['topmenu_items'] = topmenu_items('my_account', self.request)
 480 # DEPRECATED #        # so we can sho who is logged
 481 # DEPRECATED #        context['username'] = the_user(self.request)
 482 # DEPRECATED #        context.update(page.prelude_env())
 483 # DEPRECATED #        return context
 484
 485 # View for platforms
 486 class PlatformsView(TemplateView):
 487     template_name = "platforms.html"
 488
 489     def get_context_data(self, **kwargs):
 490         page = Page(self.request)
 491
 492         #network_query  = Query().get('local:platform').filter_by('disabled', '==', '0').select('platform','platform_longname','gateway_type')
 493         network_query  = Query().get('local:platform').select('platform','platform_longname','gateway_type')
 494         page.enqueue_query(network_query)
 495
 496         page.expose_js_metadata()
 497         page.expose_queries()
 498         networklist = Hazelnut(
 499             page  = page,
 500             title = 'List',
 501             domid = 'checkboxes',
 502             # this is the query at the core of the slice list
 503             query = network_query,
 504             query_all = network_query,
 505             checkboxes = False,
 506             datatables_options = {
 507             # for now we turn off sorting on the checkboxes columns this way
 508             # this of course should be automatic in hazelnut
 509             'aoColumns'      : [None, None, None, None, {'bSortable': False}],
 510             'iDisplayLength' : 25,
 511             'bLengthChange'  : True,
 512             },
 513         )
 514 #
 515 #        networklist = SimpleList(
 516 #            title = None,
 517 #            page  = page,
 518 #            key   = 'platform',
 519 #            query = network_query,
 520 #        )
 521
 522         context = super(PlatformsView, self).get_context_data(**kwargs)
 523         context['person']   = self.request.user
 524         context['networks'] = networklist.render(self.request)
 525
 526         # XXX This is repeated in all pages
 527         # more general variables expected in the template
 528         context['title'] = 'Platforms connected to MySlice'
 529         # the menu items on the top
 530         context['topmenu_items'] = topmenu_items('Platforms', self.request)
 531         # so we can sho who is logged
 532         context['username'] = the_user(self.request)
 533
 534         context.update(page.prelude_env())
 535
 536         return context
 537
 538
 539
 540 # View for 1 platform and its details
 541 class PlatformView(TemplateView):
 542     template_name = "platform.html"
 543
 544     def get_context_data(self, **kwargs):
 545         page = Page(self.request)
 546
 547         for key, value in kwargs.iteritems():
 548             print "%s = %s" % (key, value)
 549             if key == "platformname":
 550                 platformname=value
 551
 552         network_query  = Query().get('local:platform').filter_by('platform', '==', platformname).select('platform','platform_longname','gateway_type')
 553         page.enqueue_query(network_query)
 554
 555         page.expose_js_metadata()
 556         page.expose_queries()
 557         networklist = Hazelnut(
 558             page  = page,
 559             title = 'List',
 560             domid = 'checkboxes',
 561             # this is the query at the core of the slice list
 562             query = network_query,
 563             query_all = network_query,
 564             checkboxes = False,
 565             datatables_options = {
 566             # for now we turn off sorting on the checkboxes columns this way
 567             # this of course should be automatic in hazelnut
 568             'aoColumns'      : [None, None, None, None, {'bSortable': False}],
 569             'iDisplayLength' : 25,
 570             'bLengthChange'  : True,
 571             },
 572         )
 573 #
 574 #        networklist = SimpleList(
 575 #            title = None,
 576 #            page  = page,
 577 #            key   = 'platform',
 578 #            query = network_query,
 579 #        )
 580
 581         context = super(PlatformView, self).get_context_data(**kwargs)
 582         context['person']   = self.request.user
 583         context['networks'] = networklist.render(self.request)
 584
 585         # XXX This is repeated in all pages
 586         # more general variables expected in the template
 587         context['title'] = 'Platforms connected to MySlice'
 588         # the menu items on the top
 589         context['topmenu_items'] = topmenu_items('Platforms', self.request)
 590         # so we can sho who is logged
 591         context['username'] = the_user(self.request)
 592
 593         context.update(page.prelude_env())
 594
 595         return context
 596
 597
 598
 599 #class for my_account
 600 class AccountView(TemplateView):
 601     template_name = "my_account.html"
 602
 603     #This view requires login
 604     @method_decorator(login_required)
 605     def dispatch(self, *args, **kwargs):
 606         return super(AccountView, self).dispatch(*args, **kwargs)
 607
 608
 609     def get_context_data(self, **kwargs):
 610         #page = Page(self.request)
 611
 612         user_query  = Query().get('local:user').select('config','email')
 613         user_details = execute_query(self.request, user_query)
 614
 615         for user_detail in user_details:
 616             #email = user_detail['email']
 617             if user_detail['config']:
 618                 config = json.loads(user_detail['config'])
 619
 620         platform_query  = Query().get('local:platform').select('platform_id','platform')
 621         account_query  = Query().get('local:account').select('user_id','platform_id','auth_type','config')
 622         platform_details = execute_query(self.request, platform_query)
 623         account_details = execute_query(self.request, account_query)
 624
 625         # initial assignment needed for users having no account
 626         platform_name = ''
 627         account_type = ''
 628         account_usr_hrn = ''
 629         account_pub_key = ''
 630         for account_detail in account_details:
 631             for platform_detail in platform_details:
 632                 if platform_detail['platform_id'] == account_detail['platform_id']:
 633                     platform_name = platform_detail['platform']
 634                     account_type = account_detail['auth_type']
 635                     account_config = json.loads(account_detail['config'])
 636
 637                     if 'user_hrn' in account_config:
 638                         account_usr_hrn = account_config['user_hrn']
 639                     else:
 640                         account_usr_hrn = 'N/A'
 641                     if 'user_public_key' in account_config:
 642                         account_pub_key = account_config['user_public_key']
 643                     else:
 644                         account_pub_key = 'N/A'
 645                         #print "THis is a test"
 646                         #print account_pub_key
 647
 648         #page.enqueue_query(network_query)
 649
 650         #page.expose_js_metadata()
 651         #page.expose_queries()
 652
 653         #userlist = SimpleList(
 654         #    title = None,
 655         #    page  = page,
 656         #    key   = 'user_id',
 657         #    query = network_query,
 658         #)
 659
 660         context = super(AccountView, self).get_context_data(**kwargs)
 661         context['platform_name'] = platform_name
 662         context['account_type'] = account_type
 663         context['account_usr_hrn'] = account_usr_hrn
 664         context['account_pub_key'] = account_pub_key
 665         context['person']   = self.request.user
 666         context ['fullname'] = config['firstname'] +' '+ config['lastname']
 667         context ['firstname'] = config['firstname']
 668         context ['lastname'] = config['lastname']
 669         context ['affiliation'] = config['affiliation']
 670         #context['users'] = userlist.render(self.request)
 671
 672         # XXX This is repeated in all pages
 673         # more general variables expected in the template
 674         context['title'] = 'Platforms connected to MySlice'
 675         # the menu items on the top
 676         context['topmenu_items'] = topmenu_items('My Account', self.request)
 677         # so we can sho who is logged
 678         context['username'] = the_user(self.request)
 679         context ['firstname'] = config['firstname']
 680         #context.update(page.prelude_env())
 681         return context
 682
 683
 684
 685
 686
 687
 688 @login_required
 689 # View for my_account form
 690 #def my_account(request):
 691 #    return render(request, 'my_account.html', {
 692 #        #'form': form,
 693 #        'topmenu_items': topmenu_items('My Account', request),
 694 #        'username': the_user (request)
 695 #    })
 696
 697
 698 @login_required
 699 #my_acc form value processing
 700 def acc_process(request):
 701     # getting the user_id from the session [now hardcoded]
 702     get_user = PendingUser.objects.get(id='1') # here we will get the id/email from session e.g., person.email
 703     # getting user info from manifold
 704     if 'submit_name' in request.POST:
 705         edited_first_name =  request.POST['fname']
 706         edited_last_name =  request.POST['lname']
 707         #email = 'test_email@gmail.com'
 708         #password = 'test_pp'
 709         #message = 'F_Name: %s L_name: %s dummy_pp: %s' % (first_name, last_name, password)
 710         #site = None
 711
 712         # insert into DB [needed for registration page]
 713         #approach borrowed from register view
 714         #new_user = PendingUser.objects.create_inactive_user(edited_first_name, edited_last_name, email,  password, site)
 715         #conventional approach
 716         #b = PendingUser(first_name=edited_first_name, last_name=edited_last_name)
 717         #b.save()
 718
 719         # select and update [will be used throughout this view]
 720         # select the logged in user [for the moment hard coded]
 721         #get_user = PendingUser.objects.get(id='1') # here we will get the id/email from session e.g., person.email
 722         # update first and last name
 723         get_user.first_name = edited_first_name
 724         get_user.last_name = edited_last_name
 725         get_user.save()
 726
 727         return HttpResponse('Sucess: First Name and Last Name Updated!')
 728     elif 'submit_pass' in request.POST:
 729         edited_password = request.POST['password']
 730         # select the logged in user [for the moment hard coded]
 731         #get_user = PendingUser.objects.get(id='1') # here we will get the id/email from session e.g., person.email
 732         # update password
 733         get_user.password = edited_password
 734         get_user.save()
 735         return HttpResponse('Success: Password Changed!!')
 736     elif 'generate' in request.POST:
 737         # Generate public and private keys using SFA Library
 738         from sfa.trust.certificate  import Keypair
 739         k = Keypair(create=True)
 740         public_key = k.get_pubkey_string()
 741         private_key = k.as_pem()
 742
 743 # DEPRECATED
 744 #        KEY_LENGTH = 2048
 745 #
 746 #        def blank_callback():
 747 #            "Replace the default dashes"
 748 #            return
 749 #
 750 #        # Random seed
 751 #        Rand.rand_seed (os.urandom (KEY_LENGTH))
 752 #        # Generate key pair
 753 #        key = RSA.gen_key (KEY_LENGTH, 65537, blank_callback)
 754 #        # Create memory buffers
 755 #        pri_mem = BIO.MemoryBuffer()
 756 #        pub_mem = BIO.MemoryBuffer()
 757 #        # Save keys to buffers
 758 #        key.save_key_bio(pri_mem, None)
 759 #        key.save_pub_key_bio(pub_mem)
 760 #
 761 #        # Get keys
 762 #        public_key = pub_mem.getvalue()
 763 #        private_key = pri_mem.getvalue()
 764         private_key = ''.join(private_key.split())
 765         public_key = "ssh-rsa " + public_key
 766         # Saving to DB
 767         keypair = '{"user_public_key":"'+ public_key + '", "user_private_key":"'+ private_key + '"}'
 768 #        keypair = re.sub("\r", "", keypair)
 769 #        keypair = re.sub("\n", "\\n", keypair)
 770 #        #keypair = keypair.rstrip('\r\n')
 771 #        keypair = ''.join(keypair.split())
 772         get_user.keypair = keypair
 773         get_user.save()
 774         return HttpResponse('Success: New Keypair Generated! %s' % keypair)
 775
 776     elif 'upload_key' in request.POST:
 777         up_file = request.FILES['pubkey']
 778         file_content =  up_file.read()
 779         file_name = up_file.name
 780         file_extension = os.path.splitext(file_name)[1]
 781         allowed_extension =  ['.pub','.txt']
 782         if file_extension in allowed_extension and re.search(r'ssh-rsa',file_content):
 783             file_content = '{"user_public_key":"'+ file_content +'"}'
 784             file_content = re.sub("\r", "", file_content)
 785             file_content = re.sub("\n", "\\n",file_content)
 786             file_content = ''.join(file_content.split())
 787             get_user.keypair = file_content
 788             get_user.save()
 789             return HttpResponse('Success: Publickey uploaded! Old records overwritten')
 790         else:
 791             return HttpResponse('Please upload a valid RSA public key [.txt or .pub].')
 792
 793     else:
 794         message = 'You submitted an empty form.'
 795         return HttpResponse(message)
 796
 797 def register_4m_f4f(request):
 798     errors = []
 799
 800     authorities_query = Query.get('authority').filter_by('authority_hrn', 'included', ['ple.inria', 'ple.upmc']).select('name', 'authority_hrn')
 801     #authorities_query = Query.get('authority').select('authority_hrn')
 802     authorities = execute_query(request, authorities_query)
 803
 804     if request.method == 'POST':
 805         # We shall use a form here
 806
 807         #get_email = PendingUser.objects.get(email)
 808         reg_fname = request.POST.get('firstname', '')
 809         reg_lname = request.POST.get('lastname', '')
 810         reg_aff = request.POST.get('affiliation','')
 811         reg_auth = request.POST.get('authority_hrn', '')
 812         reg_email = request.POST.get('email','').lower()
 813
 814         #POST value validation
 815         if (re.search(r'^[\w+\s.@+-]+$', reg_fname)==None):
 816             errors.append('First Name may contain only letters, numbers, spaces and @/./+/-/_ characters.')
 817             #return HttpResponse("Only Letters, Numbers, - and _ allowd in First Name")
 818             #return render(request, 'register_4m_f4f.html')
 819         if (re.search(r'^[\w+\s.@+-]+$', reg_lname) == None):
 820             errors.append('Last Name may contain only letters, numbers, spaces and @/./+/-/_ characters.')
 821             #return HttpResponse("Only Letters, Numbers, - and _ is allowed in Last name")
 822             #return render(request, 'register_4m_f4f.html')
 823         if (re.search(r'^[\w+\s.@+-]+$', reg_aff) == None):
 824             errors.append('Affiliation may contain only letters, numbers, spaces and @/./+/-/_ characters.')
 825             #return HttpResponse("Only Letters, Numbers and _ is allowed in Affiliation")
 826             #return render(request, 'register_4m_f4f.html')
 827         # XXX validate authority hrn !!
 828         if PendingUser.objects.filter(email__iexact=reg_email):
 829             errors.append('Email already registered.Please provide a new email address.')
 830             #return HttpResponse("Email Already exists")
 831             #return render(request, 'register_4m_f4f.html')
 832         if 'generate' in request.POST['question']:
 833             # Generate public and private keys using SFA Library
 834             from sfa.trust.certificate  import Keypair
 835             k = Keypair(create=True)
 836             public_key = k.get_pubkey_string()
 837             private_key = k.as_pem()
 838
 839 # DEPRECATED
 840 #            #import os
 841 #            #from M2Crypto import Rand, RSA, BIO
 842 #
 843 #            KEY_LENGTH = 2048
 844 #
 845 #            def blank_callback():
 846 #                "Replace the default dashes"
 847 #                return
 848 #
 849 #            # Random seed
 850 #            Rand.rand_seed (os.urandom (KEY_LENGTH))
 851 #            # Generate key pair
 852 #            key = RSA.gen_key (KEY_LENGTH, 65537, blank_callback)
 853 #            # Create memory buffers
 854 #            pri_mem = BIO.MemoryBuffer()
 855 #            pub_mem = BIO.MemoryBuffer()
 856 #            # Save keys to buffers
 857 #            key.save_key_bio(pri_mem, None)
 858 #            key.save_pub_key_bio(pub_mem)
 859 #            # Get keys
 860 #            public_key = pub_mem.getvalue()
 861 #            private_key = pri_mem.getvalue()
 862
 863             private_key = ''.join(private_key.split())
 864             public_key = "ssh-rsa " + public_key
 865             # Saving to DB
 866             keypair = '{"user_public_key":"'+ public_key + '", "user_private_key":"'+ private_key + '"}'
 867 #            keypair = re.sub("\r", "", keypair)
 868 #            keypair = re.sub("\n", "\\n", keypair)
 869 #            #keypair = keypair.rstrip('\r\n')
 870 #            keypair = ''.join(keypair.split())
 871         else:
 872             up_file = request.FILES['user_public_key']
 873             file_content =  up_file.read()
 874             file_name = up_file.name
 875             file_extension = os.path.splitext(file_name)[1]
 876             allowed_extension =  ['.pub','.txt']
 877             if file_extension in allowed_extension and re.search(r'ssh-rsa',file_content):
 878                 keypair = '{"user_public_key":"'+ file_content +'"}'
 879                 keypair = re.sub("\r", "", keypair)
 880                 keypair = re.sub("\n", "\\n",keypair)
 881                 keypair = ''.join(keypair.split())
 882             else:
 883                 errors.append('Please upload a valid RSA public key [.txt or .pub].')
 884
 885         #b = PendingUser(first_name=reg_fname, last_name=reg_lname, affiliation=reg_aff,
 886         #                email=reg_email, password=request.POST['password'], keypair=keypair)
 887         #b.save()
 888         if not errors:
 889             b = PendingUser(
 890                 first_name=reg_fname,
 891                 last_name=reg_lname,
 892                 affiliation=reg_aff,
 893                 authority_hrn=reg_auth,
 894                 email=reg_email,
 895                 password=request.POST['password'],
 896                 keypair=keypair
 897             )
 898             b.save()
 899
 900             # Send email
 901             ctx = {
 902                 first_name   : reg_fname,
 903                 last_name    : reg_lname,
 904                 affiliation  : reg_aff,
 905                 authority_hrn: reg_auth,
 906                 email        : reg_email,
 907                 keypair      : keypair,
 908                 cc_myself    : True # form.cleaned_data['cc_myself']
 909             }
 910
 911             recipients = authority_get_pi_emails(authority_hrn)
 912             if ctx['cc_myself']:
 913                 recipients.append(ctx['email'])
 914
 915             msg = render_to_string('user_request_email.txt', ctx)
 916             send_mail("Onelab New User request submitted", msg, email, recipients)
 917
 918             return render(request, 'user_register_complete.html')
 919
 920     return render(request, 'register_4m_f4f.html',{
 921         'topmenu_items': topmenu_items('Register', request),
 922         'errors': errors,
 923         'firstname': request.POST.get('firstname', ''),
 924         'lastname': request.POST.get('lastname', ''),
 925         'affiliation': request.POST.get('affiliation', ''),
 926         'authority_hrn': request.POST.get('authority_hrn', ''),
 927         'email': request.POST.get('email', ''),
 928         'password': request.POST.get('password', ''),
 929         'authorities': authorities
 930     })
 931
 932
 933 # view for contact form
 934 def contact(request):
 935     if request.method == 'POST': # If the form has been submitted...
 936         form = ContactForm(request.POST) # A form bound to the POST data
 937         if form.is_valid(): # All validation rules pass
 938             # Process the data in form.cleaned_data
 939             first_name = form.cleaned_data['first_name']
 940             last_name = form.cleaned_data['last_name']
 941             affiliation = form.cleaned_data['affiliation']
 942             subject = form.cleaned_data['subject']
 943             message = form.cleaned_data['message']
 944             email = form.cleaned_data['email'] # email of the sender
 945             cc_myself = form.cleaned_data['cc_myself']
 946
 947             #recipients = authority_get_pi_emails(authority_hrn)
 948             recipients = ['yasin.upmc@gmail.com']
 949             if cc_myself:
 950                 recipients.append(email)
 951
 952             from django.core.mail import send_mail
 953             send_mail("Onelab user submitted a query ", [first_name,last_name,affiliation,subject,message], email, recipients)
 954             return render(request,'contact_sent.html') # Redirect after POST
 955     else:
 956         form = ContactForm() # An unbound form
 957
 958     return render(request, 'contact.html', {
 959         'form': form,
 960         'topmenu_items': topmenu_items('Contact Us', request),
 961         'username': the_user (request)
 962
 963     })
 964
 965 @login_required
 966 def slice_request(request):
 967     errors = []
 968
 969     authorities_query = Query.get('authority').filter_by('authority_hrn', 'included', ['ple.inria', 'ple.upmc']).select('name', 'authority_hrn')
 970     #authorities_query = Query.get('authority').select('authority_hrn')
 971     authorities = execute_query(request, authorities_query)
 972
 973     authority_hrn_tuple = []
 974     for authority in authorities:
 975         authority_hrn_tuple.append((authority['authority_hrn'], authority['name']))
 976     authority_hrn_initial = {'authority_hrn': authority_hrn_tuple}
 977
 978     # request.POST or None ?
 979     if request.method == 'POST':
 980         # The form has been submitted
 981         form = SliceRequestForm(request.POST, initial=authority_hrn_initial)
 982
 983         if form.is_valid():
 984             slice_name      = form.cleaned_data['slice_name']
 985             authority_hrn   = form.cleaned_data['authority_hrn']
 986             number_of_nodes = form.cleaned_data['number_of_nodes']
 987             type_of_nodes   = form.cleaned_data['type_of_nodes']
 988             purpose         = form.cleaned_data['purpose']
 989
 990             s = PendingSlice(
 991                 slice_name      = slice_name,
 992                 authority_hrn   = authority_hrn,
 993                 number_of_nodes = number_of_nodes,
 994                 type_of_nodes   = type_of_nodes,
 995                 purpose         = purpose
 996             )
 997             s.save()
 998
 999             # All validation rules pass; process data in form.cleaned_data
1000             # slice_name, number_of_nodes, type_of_nodes, purpose
1001             email = form.cleaned_data['email'] # email of the sender
1002             cc_myself = form.cleaned_data['cc_myself']
1003
1004             # The recipients are the PI of the authority
1005             recipients = authority_get_pi_emails(authority_hrn)
1006             #recipients = ['yasin.upmc@gmail.com','jordan.auge@lip6.fr']
1007             if cc_myself:
1008                 recipients.append(email)
1009             msg = render_to_string('slice_request_email.txt', form.cleaned_data)
1010             send_mail("Onelab New Slice request form submitted", msg, email, recipients)
1011
1012             return render(request,'slicereq_recvd.html') # Redirect after POST
1013     else:
1014         form = SliceRequestForm(initial=authority_hrn_initial)
1015
1016 #    template_env = {}
1017 #    template_env['form'] = form
1018 #    template_env['topmenu_items'] = topmenu_items('Request a slice', request)
1019 #    template_env['unfold1_main'] = render(request, 'slice_request_.html', {
1020 #        'form': form,
1021 #    })
1022 #    from django.shortcuts                import render_to_response
1023 #    from django.template                 import RequestContext
1024 #    return render_to_response ('view-unfold1.html',template_env,
1025 #                               context_instance=RequestContext(request))
1026
1027     return render(request, 'slice_request.html', {
1028         'form': form,
1029         'topmenu_items': topmenu_items('Request a slice', request),
1030         'username': the_user (request)
1031     })
1032
1033
1034 class PresViewView(TemplateView):
1035     template_name = "view-unfold1.html"
1036
1037     def get_context_data(self, **kwargs):
1038
1039         page = Page(self.request)
1040
1041         pres_view = PresView(page = page)
1042
1043         context = super(PresViewView, self).get_context_data(**kwargs)
1044
1045         #context['ALL_STATIC'] = "all_static"
1046         context['unfold1_main'] = pres_view.render(self.request)
1047
1048         # XXX This is repeated in all pages
1049         # more general variables expected in the template
1050         context['title'] = 'Test view that combines various plugins'
1051         # the menu items on the top
1052         context['topmenu_items'] = topmenu_items('PresView', self.request)
1053         # so we can sho who is logged
1054         context['username'] = the_user(self.request)
1055
1056         prelude_env = page.prelude_env()
1057         context.update(prelude_env)
1058
1059         return context
1060
1061 def json_me(config_file,type):
1062     json_answer = ''
1063     for ligne in config_file:
1064         if not ligne.startswith('#'):
1065             args = ligne.split(';')
1066             json_answer += str('{ "name": "' + args[0] + '" ,"id":"' + args[1]  + '" ,"descriptif":"' + args[2]+'"')
1067             if type!="dynamic":
1068                 json_answer += str(',"contraints":')
1069                 if args[3]=="":
1070                     json_answer += str('""')
1071                 else:
1072                     json_answer += str(args[3])
1073             json_answer += str('},')
1074     return json_answer[:-1]
1075
1076
1077 DIR = '/var/myslice/'
1078 STATIC = '%s/config_method_static' % DIR
1079 DYNAMIC = '%s/config_method_dynamic' % DIR
1080 ANIMATION = '%s/config_method_animation' % DIR
1081
1082 def pres_view_methods(request, type):
1083
1084     if type ==None:
1085         return 0
1086     elif type =="static":
1087         config = open(STATIC, "r")
1088         json_answer = str('{ "options": [')
1089         json_answer += str(json_me(config,"static"))
1090         json_answer += str('] }')
1091         config.close()
1092     elif type =="dynamic":
1093         config = open(DYNAMIC, "r")
1094         json_answer = str('{ "options": [')
1095         json_answer += str(json_me(config,"dynamic"))
1096         json_answer += str('] }')
1097         config.close()
1098     elif type =="animation":
1099         config = open(ANIMATION, "r")
1100         json_answer = str('{ "options": [')
1101         json_answer += str(json_me(config,"animation"))
1102         json_answer += str('] }')
1103         config.close()
1104     elif type =="all":
1105         config = open(STATIC, "r")
1106         json_answer = str('{ "static": [')
1107         json_answer += str(json_me(config,"static"))
1108         json_answer += str('],')
1109         json_answer += str('"dynamic": [')
1110         config.close()
1111         config = open(DYNAMIC, "r")
1112         json_answer += str(json_me(config,"dynamic"))
1113         json_answer += str('],')
1114         json_answer += str('"animation": [')
1115         config.close()
1116         config = open(ANIMATION, "r")
1117         json_answer += str(json_me(config,"animation"))
1118         json_answer += str('] }')
1119         config.close()
1120     else:
1121         return 0
1122     return HttpResponse (json_answer, mimetype="application/json")
1123
1124 def pres_view_animation(request, constraints, id):
1125
1126 # sites crees depuis 2008
1127 # static.py?contraints=']date_created':1262325600&id='name_id"'
1128
1129     # method = request.getvalue('method') #ex : GetSites
1130     #constraints = "']date_created':1262325600"
1131     #id = "2"
1132
1133     if id == None:
1134         return 0
1135
1136     # method = 'GetSites'#request.getvalue('method') #ex : GetSites
1137     # constraints = {}#request.getvalue('constraints') // nul = {}
1138     # response_field = "'site_id','name','date_created'"#request.getvalue('response_field')
1139
1140     config_file = open(ANIMATION, "r")
1141     for ligne in config_file:
1142         if not ligne.startswith('#'):
1143             ligne = ligne.split('\n')
1144             first = ligne[0].split(';')
1145             if (str(first[1]) == str(id)):
1146                 save = first
1147     config_file.close()
1148
1149     #Les print_method, print_option sont definis par le client (js)
1150     #Les animations acceptent que les connexions anonymous
1151     # args = "postmsg;animation;;;anonymous;https://www.planet-lab.eu/PLCAPI/;"
1152     args = ";;"+str(save[8])+";"+str(save[9])+";anonymous;"+str(save[5])+";"+str(save[6])+";{"+str(constraints)+"};"+str(save[7])+";"
1153
1154
1155     #Creation d'un objet event
1156     event = Event(args)
1157     cmd = [{"params": {
1158             "data": {
1159                 "print_options": event.print_options,
1160                 "print_method": event.print_method,
1161                 "message": event.data
1162             }
1163         }
1164     }]
1165
1166     json_answer = json.dumps(cmd)
1167     return HttpResponse (json_answer, mimetype="application/json")
1168
1169 def pres_view_static(request, constraints, id):
1170     #constraints = "']date_created':1262325600"
1171     #id = "2"
1172
1173     # method = 'GetSites'#request.getvalue('method') #ex : GetSites
1174     # constraints = {}#request.getvalue('constraints') // nul = {}
1175     # response_field = "'site_id','name','date_created'"#request.getvalue('response_field')
1176
1177     config_file = open(STATIC, "r")
1178     for ligne in config_file:
1179         if not ligne.startswith('#'):
1180             ligne = ligne.split('\n')
1181             first = ligne[0].split(';')
1182             if (str(first[1]) == str(id)):
1183                 save = first
1184     config_file.close()
1185
1186     #Les print_method, print_option sont definis par le client (js)
1187     #Les animations acceptent que les connexions anonymous
1188     # args = "postmsg;animation;;;anonymous;https://www.planet-lab.eu/PLCAPI/;"
1189     args = ";;"+str(save[8])+";"+str(save[9])+";anonymous;"+str(save[5])+";"+str(save[6])+";{"+str(constraints)+"};"+str(save[7])+";"
1190
1191
1192     #Creation d'un objet event
1193     event = Event(args)
1194     cmd = [{"params": {
1195             "data": {
1196                 "print_options": event.print_options,
1197                 "print_method": event.print_method,
1198                 "message": event.data
1199             }
1200         }
1201     }]
1202
1203     json_answer = json.dumps(cmd)
1204     return HttpResponse (json_answer, mimetype="application/json")
1205
1206 class ValidatePendingView(TemplateView):
1207     template_name = "validate_pending.html"
1208
1209     def get_context_data(self, **kwargs):
1210         # We might have slices on different registries with different user accounts
1211         # 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
1212         # Different registries mean different identities, unless we identify via SFA HRN or have associated the user email to a single hrn
1213
1214         #messages.info(self.request, 'You have logged in')
1215         page = Page(self.request)
1216
1217         ctx_my_authorities = {}
1218         ctx_delegation_authorities = {}
1219
1220
1221         # The user need to be logged in
1222         if the_user(self.request):
1223             # Who can a PI validate:
1224             # His own authorities + those he has credentials for.
1225             # In MySlice we need to look at credentials also.
1226
1227
1228             # XXX This will have to be asynchroneous. Need to implement barriers,
1229             # for now it will be sufficient to have it working statically
1230
1231             # get user_id to later on query accounts
1232             # XXX Having real query plan on local tables would simplify all this
1233             # XXX $user_email is still not available for local tables
1234             #user_query = Query().get('local:user').filter_by('email', '==', '$user_email').select('user_id')
1235             user_query = Query().get('local:user').filter_by('email', '==', the_user(self.request)).select('user_id')
1236             user, = execute_query(self.request, user_query)
1237             user_id = user['user_id']
1238
1239             # Query manifold to learn about available SFA platforms for more information
1240             # In general we will at least have the portal
1241             # For now we are considering all registries
1242             all_authorities = []
1243             platform_ids = []
1244             sfa_platforms_query = Query().get('local:platform').filter_by('gateway_type', '==', 'sfa').select('platform_id', 'platform', 'auth_type')
1245             sfa_platforms = execute_query(self.request, sfa_platforms_query)
1246             for sfa_platform in sfa_platforms:
1247                 print "SFA PLATFORM > ", sfa_platform['platform']
1248                 if not 'auth_type' in sfa_platform:
1249                     continue
1250                 auth = sfa_platform['auth_type']
1251                 if not auth in all_authorities:
1252                     all_authorities.append(auth)
1253                 platform_ids.append(sfa_platform['platform_id'])
1254
1255             # We can check on which the user has authoritity credentials = PI rights
1256             credential_authorities = set()
1257             credential_authorities_expired = set()
1258
1259             # User account on these registries
1260             user_accounts_query = Query.get('local:account').filter_by('user_id', '==', user_id).filter_by('platform_id', 'included', platform_ids).select('config')
1261             user_accounts = execute_query(self.request, user_accounts_query)
1262             #print "=" * 80
1263             #print user_accounts
1264             #print "=" * 80
1265             for user_account in user_accounts:
1266                 config = json.loads(user_account['config'])
1267                 creds = []
1268                 if 'authority_credentials' in config:
1269                     for authority_hrn, credential in config['authority_credentials'].items():
1270                         #if credential is not expired:
1271                         credential_authorities.add(authority_hrn)
1272                         #else
1273                         #    credential_authorities_expired.add(authority_hrn)
1274                 if 'delegated_authority_credentials' in config:
1275                     for authority_hrn, credential in config['delegated_authority_credentials'].items():
1276                         #if credential is not expired:
1277                         credential_authorities.add(authority_hrn)
1278                         #else
1279                         #    credential_authorities_expired.add(authority_hrn)
1280
1281             print 'credential_authorities =', credential_authorities
1282             print 'credential_authorities_expired =', credential_authorities_expired
1283
1284             # ** Where am I a PI **
1285             # For this we need to ask SFA (of all authorities) = PI function
1286             pi_authorities_query = Query.get('user').filter_by('user_hrn', '==', '$user_hrn').select('pi_authorities')
1287             pi_authorities_tmp = execute_query(self.request, pi_authorities_query)
1288             pi_authorities = set()
1289             for pa in pi_authorities_tmp:
1290                 pi_authorities |= set(pa['pi_authorities'])
1291
1292             print "pi_authorities =", pi_authorities
1293
1294             # My authorities + I have a credential
1295             pi_credential_authorities = pi_authorities & credential_authorities
1296             pi_no_credential_authorities = pi_authorities - credential_authorities - credential_authorities_expired
1297             pi_expired_credential_authorities = pi_authorities & credential_authorities_expired
1298             # Authorities I've been delegated PI rights
1299             pi_delegation_credential_authorities = credential_authorities - pi_authorities
1300             pi_delegation_expired_authorities = credential_authorities_expired - pi_authorities
1301
1302             print "pi_credential_authorities =", pi_credential_authorities
1303             print "pi_no_credential_authorities =", pi_no_credential_authorities
1304             print "pi_expired_credential_authorities =", pi_expired_credential_authorities
1305             print "pi_delegation_credential_authorities = ", pi_delegation_credential_authorities
1306             print "pi_delegation_expired_authorities = ", pi_delegation_expired_authorities
1307
1308             # Summary intermediary
1309             pi_my_authorities = pi_credential_authorities | pi_no_credential_authorities | pi_expired_credential_authorities
1310             pi_delegation_authorities = pi_delegation_credential_authorities | pi_delegation_expired_authorities
1311
1312             print "--"
1313             print "pi_my_authorities = ", pi_my_authorities
1314             print "pi_delegation_authorities = ", pi_delegation_authorities
1315
1316             # Summary all
1317             queried_pending_authorities = pi_my_authorities | pi_delegation_authorities
1318             print "----"
1319             print "queried_pending_authorities = ", queried_pending_authorities
1320
1321             requests = get_request_by_authority(queried_pending_authorities)
1322             for request in requests:
1323                 auth_hrn = request['authority_hrn']
1324
1325                 if auth_hrn in pi_my_authorities:
1326                     dest = ctx_my_authorities
1327
1328                     # define the css class
1329                     if auth_hrn in pi_credential_authorities:
1330                         request['allowed'] = 'allowed'
1331                     elif auth_hrn in pi_expired_credential_authorities:
1332                         request['allowed'] = 'expired'
1333                     else: # pi_no_credential_authorities
1334                         request['allowed'] = 'denied'
1335
1336                 elif auth_hrn in pi_delegation_authorities:
1337                     dest = ctx_delegation_authorities
1338
1339                     if auth_hrn in pi_delegation_credential_authorities:
1340                         request['allowed'] = 'allowed'
1341                     else: # pi_delegation_expired_authorities
1342                         request['allowed'] = 'expired'
1343
1344                 else:
1345                     continue
1346
1347                 if not auth_hrn in dest:
1348                     dest[auth_hrn] = []
1349                 dest[auth_hrn].append(request)
1350
1351         context = super(ValidatePendingView, self).get_context_data(**kwargs)
1352         context['my_authorities']   = ctx_my_authorities
1353         context['delegation_authorities'] = ctx_delegation_authorities
1354
1355         # XXX This is repeated in all pages
1356         # more general variables expected in the template
1357         context['title'] = 'Test view that combines various plugins'
1358         # the menu items on the top
1359         context['topmenu_items'] = topmenu_items('Dashboard', self.request)
1360         # so we can sho who is logged
1361         context['username'] = the_user(self.request)
1362
1363         # XXX We need to prepare the page for queries
1364         #context.update(page.prelude_env())
1365
1366         return context