Exemple #1
0
    def get_or_post(self, request, method):
        usera = UserAccessProfile(request)
        self.user_email = usera.username  # the_user(request)
        page = Page(request)

        self.errors = []
        #user = get_user_by_email(the_user(self.request))
        user_type = usera.user_type  #get_user_type(user)
        if user_type != 0:
            messages.error(
                page.request,
                'Error: You have not permission to access this page.')
            return HttpResponseRedirect("/")
        local_resources = getLocalResources()
        remote_resources = None

        template_name = "resources-view.html"
        template_env = {
            'topmenu_items': topmenu_items('Resources View', page.request),
            'username': usera.username,  #the_user(self.request),
            'local_resources': local_resources,
            'remote_resources': remote_resources,
            'site_name': 'Current site',
            'title': 'Site Information',
        }
        template_env.update(page.prelude_env())
        return render(request, template_name, template_env)
    def get(self, request, username='******'):

        if username == 'logged': username = '******'

        page = Page(request)

        # variables that will get passed to the view-unfold1.html template
        template_env = {}

        # write something of our own instead
        template_env['unfold_main'] = '<h1>Some title </h1>'

        # more general variables expected in the template
        template_env[
            'title'] = 'simple topmenuvalidation %(username)s' % locals()
        # the menu items on the top
        template_env['topmenu_items'] = topmenu_items_live('Slice', page)
        # so we can see who is logged
        template_env['username'] = the_user(request)

        # the prelude object in page contains a summary of the requirements() for all plugins
        # define {js,css}_{files,chunks}
        prelude_env = page.prelude_env()

        #        logger.info(prelude_env.keys())
        #        for k in [ 'js_files' ] :
        #            logger.info('prelude_env {} {} {}'.format(prelude_env,k,prelude_env[k]))

        template_env.update(prelude_env)
        result = render_to_response('view-unfold1.html',
                                    template_env,
                                    context_instance=RequestContext(request))
        return result
    def get (self, request, username='******'):

        if username=='logged': username='******'

        page=Page(request)

        # variables that will get passed to the view-unfold1.html template
        template_env = {}
        
        # write something of our own instead
        template_env ['unfold_main'] = '<h1>Some title </h1>'
        
        # more general variables expected in the template
        template_env [ 'title' ] = 'simple topmenuvalidation %(username)s'%locals()
        # the menu items on the top
        template_env [ 'topmenu_items' ] = topmenu_items_live('Slice', page) 
        # so we can see who is logged
        template_env [ 'username' ] = the_user (request) 
    
        # the prelude object in page contains a summary of the requirements() for all plugins
        # define {js,css}_{files,chunks}
        prelude_env = page.prelude_env()

#        print prelude_env.keys()
#        for k in [ 'js_files' ] :
#            print 'prelude_env',prelude_env,k,prelude_env[k]

        template_env.update(prelude_env)
        result=render_to_response ('view-unfold1.html',template_env,
                                   context_instance=RequestContext(request))
        return result
Exemple #4
0
    def get_or_post(self, request, method):
        page = Page(self.request)
        usera = UserAccessProfile(request)
        c_user = usera.user_obj  #get_user_by_email(the_user(self.request))
        user_type = usera.user_type  #get_user_type(c_user)
        if user_type != 2:
            messages.error(
                page.request,
                'Error: You have not permission to access this page.')
            return HttpResponseRedirect("/")

        template_name = "ins-experiments-view.html"
        # courses_list = Course.objects.filter(instructor_ref=c_user)

        exp_list = Experiments.objects.filter(
            course_ref__instructor_ref=c_user)

        template_env = {
            'topmenu_items': topmenu_items('Experiments List', page.request),
            # 'errors': errors,
            'username': usera.username,  #the_user(self.request),
            'exp_list': exp_list,
            'title': 'Current Experiments',
        }
        template_env.update(page.prelude_env())
        return render(request, template_name, template_env)
Exemple #5
0
    def get_context_data(self, **kwargs):
        # We might have slices on different registries with different user accounts
        # 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
        # Different registries mean different identities, unless we identify via SFA HRN or have associated the user email to a single hrn

        # messages.info(self.request, 'You have logged in')
        page = Page(self.request)
        # the page header and other stuff
        usera = UserAccessProfile(self.request)
        # c_user_email =  the_user(self.request)
        c_user = usera.user_obj  # get_user_by_email(c_user_email)
        context = super(DashboardView, self).get_context_data(**kwargs)
        context['title'] = 'Dashboard'
        context['username'] = usera.username
        context['topmenu_items'] = topmenu_items('Dashboard', page.request)
        context['active_count'] = get_count_active_slice(
            c_user, usera.session_username)
        context['course_count'] = get_count_students_course(c_user)
        context['pending_count'] = get_count_students_pending(c_user)
        context['std_exp_count'] = get_count_students_experiments(c_user)
        context['student_count'] = get_count_students(c_user)
        context['request_count'] = get_count_requests(
        ) if usera.user_type == 0 else 0
        context['bulk_count'] = get_count_bulk_experiments(c_user)
        context['user_type'] = usera.user_type
        context.update(page.prelude_env())
        return context
Exemple #6
0
    def get_context_data(self, **kwargs):

        page = Page(self.request)

        #        pres_view = PresView(page = page)
        pres_view = Raw(page=page,
                        html="<h1>PresView needs to be integrated</h1>")

        context = super(PresViewView, self).get_context_data(**kwargs)

        #context['ALL_STATIC'] = "all_static"
        context['unfold_main'] = pres_view.render(self.request)

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

        prelude_env = page.prelude_env()
        context.update(prelude_env)

        return context
Exemple #7
0
    def get_context_data(self, **kwargs):
        page = Page(self.request)
        usera = UserAccessProfile(self.request)
        q = Account.objects.get(user_ref=usera.user_obj).quota_ref
        user_plan = q.quota_title
        user_quota_size = q.quota_size
        the_date = datetime.now(tz=timezone.get_current_timezone())  # timezone.now()
        curr_start = the_date.replace(day=1).replace(hour=0, minute=0, second=0)
        curr_end = last_day_of_month(datetime.today()).replace(hour=23, minute=59, second=59)
        # user_usage = get_month_usage_hr(usera.user_obj, the_date, 't')
        user_usage = get_month_usage_credit(usera.user_obj, the_date)
        user_usage_p = user_usage / user_quota_size * 100

        year_vl, year_vv = get_last_year(usera.user_obj, the_date, 'v')
        year_sl, year_sv = get_last_year(usera.user_obj, the_date, 's')
        year_l, year_v = get_last_year(usera.user_obj, the_date, 't')

        context = super(StatsView, self).get_context_data(**kwargs)
        context['user_plan'] = user_plan
        context['user_quota_size'] = user_quota_size
        context['user_usage'] = user_usage
        context['user_usage_p'] = user_usage_p
        context['curr_start'] = curr_start
        context['curr_end'] = curr_end
        context['year_vv'] = year_vv
        context['year_sv'] = year_sv
        context['year_l'] = year_l
        context['year_v'] = year_v

        context['username'] = UserAccessProfile(self.request).username  # the_user(self.request)
        context['topmenu_items'] = topmenu_items('Testbed View', page.request)
        prelude_env = page.prelude_env()
        context.update(prelude_env)
        return context
Exemple #8
0
    def get_or_post(self, wsgi_request, method):
        """
        """
        errors = []

        authorities = getAuthorities(wsgi_request, admin = True)

        #authority_hrn = None
        ## REGISTRY ONLY TO BE REMOVED WITH MANIFOLD-V2
        #authorities_query = Query.get('authority').select('name', 'authority_hrn')
        #authorities = execute_admin_query(wsgi_request, authorities_query)
        #if authorities is not None:
        #    # Remove the root authority from the list
        #    matching = [s for s in authorities if "." in s['authority_hrn']]
        #    authorities = sorted(matching, key=lambda k: k['authority_hrn'])
        #    authorities = sorted(matching, key=lambda k: k['name'])
        
        logger.debug("############ BREAKPOINT 1 #################")
        # Page rendering
        page = Page(wsgi_request)

        page.add_css_files ( [ "https://code.jquery.com/ui/1.11.2/themes/smoothness/jquery-ui.css" ] )

        page.add_js_files  ( [ "js/jquery.validate.js", "js/my_account.register.js", "js/jquery.qtip.min.js","js/jquery-ui.js","js/jquery-ui-combobox.js" ] )

        page.add_css_files ( [ "css/onelab.css", "css/registration.css", "css/jquery.qtip.min.css", "css/jquery.ui.combobox.css" ] )
        page.expose_js_metadata()
        logger.debug("############ BREAKPOINT 2 #################")
        if method == 'POST':
            reg_form = {}
Exemple #9
0
    def get_or_post(self, request, method):
        usera = UserAccessProfile(request)
        self.user_email = usera.username  # the_user(request)
        page = Page(request)

        self.errors = []
        # user = get_user_by_email(the_user(self.request))
        user_type = usera.user_type  # get_user_type(user)
        if user_type != 0:
            messages.error(
                page.request,
                'Error: You have not permission to access this page.')
            return HttpResponseRedirect("/")

        resourceslist = VirtualNode.objects.all()

        if method == 'POST':
            self.errors = []

        template_name = "fed-resources.html"
        template_env = {
            'topmenu_items': topmenu_items('Site Information', page.request),
            'username': usera.username,  # the_user(self.request),
            'resourceslist': resourceslist,
            'title': 'Resources Information',
        }
        template_env.update(page.prelude_env())
        return render(request, template_name, template_env)
Exemple #10
0
    def get_or_post(self, request, method):
        usera = UserAccessProfile(request)
        self.user_email = usera.username  # the_user(request)
        page = Page(request)

        server_type = "omf"
        request_date = timezone.now()

        if request.POST:  # method == 'POST':
            self.errors = []
            request_date = request.POST.get('request_date', timezone.now())
            server_type = request.POST.get('server_type', 'omf')
            request_date = parser.parse(request_date)

        # node_list = get_node_list(server_type)
        reserve_list = get_reservation_list(server_type, request_date)

        template_env = {
            #'topmenu_items': topmenu_items('Scheduler View', page.request),
            'username': usera.username,
            'server_type': request.POST.get('server_type', server_type),
            'sim_enable': SIM_RESERVATION,
            'errors': self.errors,
            'title': "Scheduler View",
            'request_date': request_date,
            # 'node_list': node_list,
            'reserve_list': reserve_list,
        }
        template_env.update(page.prelude_env())
        return render(request, 'scheduler-view.html', template_env)
Exemple #11
0
    def get_or_post(self, request, method):
        user_a = UserAccessProfile(request)
        self.user_email = user_a.username  # the_user(request)
        page = Page(request)

        self.errors = []
        user_type = user_a.user_type  # get_user_type(user)
        if user_type != 0:
            messages.error(
                page.request,
                'Error: You have not permission to access this page.')
            return HttpResponseRedirect("/")

        # site = None
        try:
            site = Site.objects.get(id=1)
        except Site.DoesNotExist:
            site = None

        if site is None:
            site = Site(id=1)
            private_key, public_key = UserModules.create_keys()
            site.private_key = private_key
            site.public_key = public_key
            site.save()

        if method == 'POST':
            self.errors = []
            site_name = request.POST.get('site_name', None)
            site_url = request.POST.get('site_url', None)
            site_ip = request.POST.get('site_url', None)
            site_location = request.POST.get('site_location', None)
            site_contact = request.POST.get('site_contact', None)

            if not self.errors and site:
                site.name = site_name
                site.url = site_url
                site.ip = site_ip
                site.location = site_location
                site.contact_email = site_contact
                site.save()
                messages.success(request, 'Success: Update site information')

        template_name = "fed-site.html"
        template_env = {
            'topmenu_items': topmenu_items('Site Information', page.request),
            'username': user_a.username,  # the_user(self.request),
            'site_name': site.name,
            'site_url': site.url,
            'site_ip': site.ip,
            'site_location': site.location,
            'site_contact': site.contact_email,
            'site_pkey': site.public_key,
            'site_info': 1,
            'title': 'Site Information',
        }
        template_env.update(page.prelude_env())
        return render(request, template_name, template_env)
Exemple #12
0
    def get_context_data(self, **kwargs):
        # messages.info(self.request, 'You have logged in')
        page = Page(self.request)
        ctx_my_authorities = {}
        # The user need to be logged in
        usera = UserAccessProfile(self.request)
        if usera.username:
            user = usera.user_obj  # get_user_by_email(u_email=the_user(page.request))
            pi_authorities_tmp = Authority.objects.filter(
                authority_hrn=user.authority_hrn).all()
            pi_authorities = set()
            for pa in pi_authorities_tmp:
                # pi_authorities |= set(pa.authority_hrn) #['pi_authorities'])
                pi_authorities = pi_authorities.union([user.authority_hrn])

            pi_my_authorities = pi_authorities

            # Summary all
            # @qursaan
            # iterate on the requests and check if the authority matches a prefix startswith an authority on which the user is PI
            requests = get_requests()

            # requests = get_requests(queried_pending_authorities)
            for request in requests:
                auth_hrn = request['authority_hrn']
                if user.is_admin == 1 and auth_hrn:
                    for my_auth in pi_my_authorities:
                        if auth_hrn.startswith(my_auth):
                            # dest = ctx_my_authorities
                            request['allowed'] = 'allowed'

                if 'allowed' not in request:
                    request['allowed'] = 'denied'
                # print "authority for this request", auth_hrn

                if auth_hrn in pi_my_authorities:
                    # dest = ctx_my_authorities
                    if not auth_hrn in ctx_my_authorities:
                        ctx_my_authorities[auth_hrn] = []
                    ctx_my_authorities[auth_hrn].append(request)

        context = super(ValidatePendingView, self).get_context_data(**kwargs)
        context['my_authorities'] = ctx_my_authorities
        # context['sub_authorities']   = ctx_sub_authorities
        # context['delegation_authorities'] = ctx_delegation_authorities
        context['is_admin'] = user.is_admin
        # XXX This is repeated in all pages
        # more general variables expected in the template
        context['title'] = 'Validate Requests'
        # the menu items on the top
        context['topmenu_items'] = topmenu_items('Validation', page.request)
        # so we can sho who is logged
        context['username'] = usera.username

        # XXX We need to prepare the page for queries
        context.update(page.prelude_env())

        return context
Exemple #13
0
 def get_context_data(self, **kwargs):
     page = Page(self.request)
     prelude_env = page.prelude_env()
     context = super(GraphicBuilderView, self).get_context_data(**kwargs)
     context['title'] = 'Graphic Builder Tools'
     # the menu items on the top
     context['topmenu_items'] = topmenu_items('Graphic Builder', page.request)  # @qursaan change from _live
     # so we can sho who is logged
     context['username'] = the_user(self.request)
     context.update(prelude_env)
     return context
Exemple #14
0
    def get_context_data(self, **kwargs):
        page = Page(self.request)

        #node_list = Node.objects.all()

        context = super(TimelineView, self).get_context_data(**kwargs)
        #context['node_list'] = node_list
        context['last_update'] = datetime.now()
        context['title'] = 'TIMELINE VIEW'
        context['username'] = UserAccessProfile(self.request).username
        context['topmenu_items'] = topmenu_items('Timeline View', page.request)
        prelude_env = page.prelude_env()
        context.update(prelude_env)
        return context
Exemple #15
0
    def get_or_post(self, request, method):
        usera = UserAccessProfile(request)
        self.user_email = usera.username
        page = Page(request)

        if method == 'POST':
            self.errors = []

            user = usera.user_obj  # get_user_by_email(the_user(self.request))
            user_type = usera.user_type  # get_user_type(user)
            if user_type != 3:
                messages.error(
                    page.request,
                    'Error: You have not permission to access this page.')
                return HttpResponseRedirect("/")

            course_key = request.POST.get('course_key', '')

            course = Course.objects.filter(key__iexact=course_key)
            if course and not self.errors:
                s = StudentCourses(
                    students_ref=user,
                    course_ref=course[0],
                )
                s.save()
                messages.error(page.request,
                               'Success: Enroll into a new course')
            else:
                messages.error(page.request, 'Error: Course not exist')

        return HttpResponseRedirect("/lab/my_courses")
    def get_context_data(self, **kwargs):
        page = Page(self.request)
        page.add_js_files([
            "js/jquery.validate.js", "js/my_account.register.js",
            "js/my_account.edit_profile.js"
        ])
        page.add_css_files(["css/plugin.css"])

        usera = UserAccessProfile(self.request)

        c_user = usera.user_obj  #get_user_by_email(the_user(self.request))
        history_list_omf = Reservation.objects.filter(
            user_ref=c_user, username=usera.session_username)
        history_list_sim = SimReservation.objects.filter(
            user_ref=c_user, username=usera.session_username)
        context = super(SliceHistoryView, self).get_context_data(**kwargs)
        context['history_list_omf'] = history_list_omf
        context['history_list_sim'] = history_list_sim
        context['time_now'] = timezone.now
        context['title'] = 'Request Log'
        context['sim_enable'] = SIM_RESERVATION
        # the menu items on the top
        context['topmenu_items'] = topmenu_items(
            'Request Log', page.request)  # @qursaan change from _live
        # so we can sho who is logged
        context['username'] = usera.username  #the_user(self.request)
        prelude_env = page.prelude_env()
        context.update(prelude_env)
        return context
Exemple #17
0
    def get_context_data(self, **kwargs):
        page = Page(self.request)

        # This will simulate fake records in order to test the plugin
        fake_query = Query.get('ping').select('hrn', 'src_hostname',
                                              'dst_hostname', 'delay')
        fake_query_all = Query.get('ping').select('hrn', 'src_hostname',
                                                  'dst_hostname', 'delay')

        generators = {
            'hrn': 'random_string',
            'src_hostname': 'random_string',
            'dst_hostname': 'random_string',
            'delay': 'random_int'
        }
        page.generate_records(fake_query, generators, 5)
        page.generate_records(fake_query_all, generators, 20)

        plugin = MadDash(query=fake_query, query_all=fake_query_all, page=page)
        context = super(MadDashView, self).get_context_data(**kwargs)
        context['unfold_main'] = plugin.render(self.request)
        context['title'] = 'Sandbox for MadDash plugin'
        context['topmenu_items'] = topmenu_items_live('maddash', page)
        context['username'] = the_user(self.request)

        prelude_env = page.prelude_env()
        context.update(prelude_env)

        return context
Exemple #18
0
def un_complete_page(request):
    page = Page(request)
    return render(
        request,
        'uncomplete.html',
        {
            #'topmenu_items': topmenu_items('test_page', request),
            'title': 'TEST PAGE',
        })
Exemple #19
0
    def get_context_data(self, **kwargs):

        page = Page(self.request)

        plugin = MyPlugin(page=page)
        context = super(MyPluginView, self).get_context_data(**kwargs)
        context['unfold_main'] = plugin.render(self.request)

        # more general variables expected in the template
        context['title'] = 'Sandbox for MyPlugin plugin'
        # the menu items on the top
        context['topmenu_items'] = topmenu_items_live('myplugin', page)
        # so we can sho who is logged
        context['username'] = the_user(self.request)

        prelude_env = page.prelude_env()
        context.update(prelude_env)

        return context
Exemple #20
0
    def get_context_data(self, **kwargs):

        page = Page(self.request)

        plugin = MyPlugin(page = page)
        context = super(MyPluginView, self).get_context_data(**kwargs)
        context['unfold_main'] = plugin.render(self.request)

        # more general variables expected in the template
        context['title'] = 'Sandbox for MyPlugin plugin'
        # the menu items on the top
        context['topmenu_items'] = topmenu_items_live('myplugin', page)
        # so we can sho who is logged
        context['username'] = the_user(self.request)

        prelude_env = page.prelude_env()
        context.update(prelude_env)

        return context
Exemple #21
0
    def get_or_post(self, request, method):
        usera = UserAccessProfile(request)
        self.user_email = usera.username  # the_user(request)
        page = Page(request)

        self.errors = []
        # user = get_user_by_email(the_user(self.request))
        user_type = usera.user_type  # get_user_type(user)
        if user_type != 0:
            messages.error(
                page.request,
                'Error: You have not permission to access this page.')
            return HttpResponseRedirect("/")

        fedlist = Site.objects.all()

        if method == 'POST':
            self.errors = []
            '''site_name = request.POST.get('site_name', '')
            site_url = request.POST.get('site_url', '')
            site_ip = request.POST.get('site_ip', '')
            site_location = request.POST.get('site_location', '')
            site_contact = request.POST.get('site_contact', '')

            if not self.errors and site:
                site.name = site_name
                site.url = site_url
                site.ip = site_ip
                site.location = site_location
                site.contact_email = site_contact
                site.save()
                messages.success(request, 'Success: Update site information')'''

        template_name = "fed-list.html"
        template_env = {
            'topmenu_items': topmenu_items('Site Information', page.request),
            'username': usera.username,  # the_user(self.request),
            'fedlist': fedlist,
            'title': 'Site Information',
        }
        template_env.update(page.prelude_env())
        return render(request, template_name, template_env)
Exemple #22
0
    def get_context_data(self, **kwargs):
        page = Page(self.request)
        n_local_user = MyUser.objects.filter().count()
        n_remote_user = '******'  # 'Users.objects.filter().count()
        n_remote_site = Site.objects.filter().count() - 1
        n_local_resources = PhysicalNode.objects.filter().count()
        n_remote_resources = '#'

        context = super(FedView, self).get_context_data(**kwargs)
        context['fed_service'] = get_fed_status()
        context['n_local_user'] = n_local_user
        context['n_remote_user'] = n_remote_user
        context['n_remote_site'] = n_remote_site
        context['n_local_res'] = n_local_resources
        context['n_remote_res'] = n_remote_resources
        context['username'] = UserAccessProfile(self.request).username  # the_user(self.request)
        context['topmenu_items'] = topmenu_items('Testbed View', page.request)
        prelude_env = page.prelude_env()
        context.update(prelude_env)
        return context
Exemple #23
0
    def get_or_post(self, request, method):
        page = Page(self.request)
        usera = UserAccessProfile(request)
        c_user = usera.user_obj  # get_user_by_email(the_user(self.request))
        user_type = usera.user_type  # get_user_type(c_user)
        if user_type != 3:
            # messages.error(page.request, 'Error: You have not permission to access this page.')
            return HttpResponseRedirect("/")

        template_name = "std-courses-view.html"
        add_all_courses_by_email(usera.username)
        courses_list = StudentCourses.objects.filter(students_ref=c_user)
        template_env = {
            'topmenu_items': topmenu_items('My Courses', page.request),
            'username': usera.username,  #the_user(self.request),
            'courses_list': courses_list,
            'title': 'My Courses',
        }
        template_env.update(page.prelude_env())
        return render(request, template_name, template_env)
Exemple #24
0
    def get_or_post(self, request, method):
        page = Page(self.request)
        usera = UserAccessProfile(request)
        c_user = usera.user_obj
        user_type = usera.user_type
        if user_type != 2:
            messages.error(page.request, 'Error: You have not permission to access this page.')
            return HttpResponseRedirect("/")

        template_name = "ins_students_manage.html"
        student_list = MyUser.objects.filter(supervisor_id=c_user.id, user_type=3)
        template_env = {
            'topmenu_items': topmenu_items('Students List', page.request),
            # 'errors': errors,
            'username': usera.username, #the_user(self.request),
            'student_list': student_list,
            'time_now': timezone.now,
            'title': 'Current Students',
        }
        template_env.update(page.prelude_env())
        return render(request, template_name, template_env)
Exemple #25
0
    def get_context_data(self, **kwargs):
        page = Page(self.request)

        # This will simulate fake records in order to test the plugin
        fake_query = Query.get('ping').select('hrn', 'src_hostname', 'dst_hostname', 'delay')
        fake_query_all = Query.get('ping').select('hrn', 'src_hostname', 'dst_hostname', 'delay')

        generators = {
            'hrn': 'random_string',
            'src_hostname': 'random_string',
            'dst_hostname': 'random_string',
            'delay': 'random_int'
        }
        page.generate_records(fake_query, generators, 5)
        page.generate_records(fake_query_all, generators, 20)

        plugin = MadDash(query = fake_query, query_all = fake_query_all, page = page)
        context = super(MadDashView, self).get_context_data(**kwargs)
        context['unfold_main'] = plugin.render(self.request)
        context['title'] = 'Sandbox for MadDash plugin'
        context['topmenu_items'] = topmenu_items_live ('maddash', page)
        context['username'] = the_user(self.request)

        prelude_env = page.prelude_env()
        context.update(prelude_env)

        return context
    def get_or_post(self, request, method):
        page = Page(self.request)
        usera = UserAccessProfile(request)
        c_user = usera.user_obj  #get_user_by_email(the_user(self.request))
        user_type = usera.user_type  #get_user_type(c_user)
        if user_type != 3:
            # messages.error(page.request, 'Error: You have not permission to access this page.')
            return HttpResponseRedirect("/")

        template_name = "std-experiments-view.html"
        s_courses_list = StudentCourses.objects.filter(students_ref=c_user)

        c_ids = []

        for c in s_courses_list:
            c_ids.append(c.course_ref.id)

        courses_list = Course.objects.filter(id__in=c_ids)
        exp_list = Experiments.objects.filter(course_ref__in=courses_list,
                                              status=0)

        res_exp_list = Experiments.objects.filter(course_ref__in=courses_list)
        std_exp_list = StudentsExperiment.objects.filter(
            students_ref=c_user, experiment_ref__in=res_exp_list)

        res_std_list_id = []
        for s in std_exp_list:
            res_std_list_id.append(s.experiment_ref.id)

        exp_list = exp_list.exclude(id__in=res_std_list_id)

        template_env = {
            'topmenu_items': topmenu_items('My Courses', page.request),
            'username': usera.username,
            'exp_list': exp_list,
            'std_exp_list': std_exp_list,
            'title': 'My Courses',
        }
        template_env.update(page.prelude_env())
        return render(request, template_name, template_env)
Exemple #27
0
    def get(self, request, authority_hrn=None, state=None):
        env = self.default_env()
        if request.user.is_authenticated():
            env['person'] = self.request.user
            if authority_hrn is None:
                # CACHE PB with fields
                page = Page(request)
                metadata = page.get_metadata()
                user_md = metadata.details_by_object('user')
                user_fields = [column['name'] for column in user_md['column']]

                # REGISTRY ONLY TO BE REMOVED WITH MANIFOLD-V2
                user_query = Query().get('myslice:user').select(
                    user_fields).filter_by('user_hrn', '==', '$user_hrn')
                #user_query  = Query().get('myslice:user').select('user_hrn','parent_authority').filter_by('user_hrn','==','$user_hrn')
                user_details = execute_query(self.request, user_query)
                try:
                    env['user_details'] = user_details[0]
                except Exception, e:
                    # If the Query fails, check in local DB
                    try:
                        user_local_query = Query().get('local:user').select(
                            'config').filter_by('email', '==',
                                                str(env['person']))
                        user_local_details = execute_query(
                            self.request, user_local_query)
                        user_local = user_local_details[0]
                        user_local_config = user_local['config']
                        user_local_config = json.loads(user_local_config)
                        user_local_authority = user_local_config.get(
                            'authority')
                        if 'user_details' not in env or 'parent_authority' not in env[
                                'user_details'] or env['user_details'][
                                    'parent_authority'] is None:
                            env['user_details'] = {
                                'parent_authority': user_local_authority
                            }
                    except Exception, e:
                        env['error'] = "Please check your Credentials"
Exemple #28
0
    def get_context_data(self, **kwargs):
        page = Page(self.request)
        page.add_js_files(["js/common.functions.js"])
        platform_query = Query().get('local:platform').filter_by(
            'disabled', '==', '0').select('platform', 'platform_longname',
                                          'gateway_type')
        #platform_query  = Query().get('local:platform').select('platform','platform_longname','gateway_type')
        page.enqueue_query(platform_query)

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

        context = super(PlatformsView, self).get_context_data(**kwargs)
        context['person'] = self.request.user
        context['platforms'] = platformlist.render(self.request)

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

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

        return context
Exemple #29
0
    def get_or_post(self, request, method):
        page = Page(self.request)
        usera = UserAccessProfile(self.request)
        c_user = usera.user_obj # get_user_by_email(the_user(self.request))
        user_type = usera.user_type # get_user_type(c_user)
        if user_type > 3:
            messages.error(page.request, 'Error: You have not permission to access this page.')
            return HttpResponseRedirect("/")
        lib_list = None
        lib_name = request.POST.get('lib_name', '')
        lib_auth = request.POST.get('lib_auth', '')
        lib_type = request.POST.get('lib_type', '')
        lib_tag = request.POST.get('lib_tag', '')
        lib_desc = request.POST.get('lib_desc', '')

        if method == 'POST':
            lib_list = CustomLibrary.objects.filter(name__icontains=lib_name, author__icontains=lib_auth,
                                                    type__icontains=lib_type, tag__icontains=lib_tag,
                                                    description__icontains=lib_desc)

        else:
            lib_list = CustomLibrary.objects.all()

        template_name = "library-view.html"
        template_env = {
            'topmenu_items': topmenu_items('Library List', page.request),
            # 'errors': errors,
            'lib_list': lib_list,
            'lib_name': lib_name,
            'lib_auth': lib_auth,
            'lib_type': lib_type,
            'lib_tag': lib_tag,
            'lib_desc': lib_desc,
            'username': usera.username, # the_user(self.request),
            'title': 'Custom Libraries',
        }
        template_env.update(page.prelude_env())
        return render(request, template_name, template_env)
Exemple #30
0
def agreement_details(request, agreement_id):
    page = Page(request)
    prelude_env = page.prelude_env()

    annotator = wsag_helper.AgreementAnnotator()
    agreement = _get_agreement(agreement_id)
    violations = _get_agreement_violations(agreement_id)
    status = _get_agreement_status(agreement_id)
    annotator.annotate_agreement(agreement, status, violations)

    violations_by_date = wsag_helper.get_violations_bydate(violations)
    context = {
        'agreement_id': agreement_id,
        'agreement': agreement,
        'status': status,
        'violations_by_date': violations_by_date
    }

    context.update(prelude_env)

    return render_to_response('violations_template.html',
                              context,
                              context_instance=RequestContext(request))
Exemple #31
0
    def get_context_data(self, **kwargs):
        page = Page(self.request)

        the_date = datetime.now(tz=timezone.get_current_timezone())  # datetime.today()
        year_l, year_v = get_total_last_year(the_date, 't')
        year_vl, year_vv = get_total_last_year(the_date, 'v')
        year_sl, year_sv = get_total_last_year(the_date, 's')
        # user_list, value_list = get_month_usage_by_users(None)
        res_l , res_v, res_c = get_total_resource_usage()

        context = super(StatsAdminView, self).get_context_data(**kwargs)
        context['year_l'] = year_l
        context['year_vv'] = year_vv
        context['year_sv'] = year_sv
        context['year_v'] = year_v
        context['res_l'] = res_l
        context['res_v'] = res_v
        context['res_c'] = res_c
        context['username'] = UserAccessProfile(self.request).username  # the_user(self.request)
        context['topmenu_items'] = topmenu_items('Testbed View', page.request)
        prelude_env = page.prelude_env()
        context.update(prelude_env)
        return context
Exemple #32
0
    def get_context_data(self, **kwargs):

        page = Page(self.request)

        debug_platform = DebugPlatform(page=page)

        context = super(PlatformView, self).get_context_data(**kwargs)

        context['ALL_STATIC'] = "all_static"
        context['unfold_main'] = debug_platform.render(self.request)

        # XXX This is repeated in all pages
        # more general variables expected in the template
        context['title'] = 'Test view that combines various plugins'
        # the menu items on the top
        context['topmenu_items'] = topmenu_items('Dashboard', self.request)
        # so we can sho who is logged
        context['username'] = the_user(self.request)

        prelude_env = page.prelude_env()
        context.update(prelude_env)

        return context
Exemple #33
0
    def get_context_data(self, **kwargs):

        page = Page(self.request)

        debug_platform = DebugPlatform(page = page)

        context = super(PlatformView, self).get_context_data(**kwargs)

        context['ALL_STATIC'] = "all_static"
        context['unfold_main'] = debug_platform.render(self.request)

        # XXX This is repeated in all pages
        # more general variables expected in the template
        context['title'] = 'Test view that combines various plugins'
        # the menu items on the top
        context['topmenu_items'] = topmenu_items('Dashboard', self.request) 
        # so we can sho who is logged
        context['username'] = the_user(self.request) 

        prelude_env = page.prelude_env()
        context.update(prelude_env)

        return context
Exemple #34
0
def agreement_term_violations(request, agreement_id, guarantee_name):
    page = Page(request)
    prelude_env = page.prelude_env()

    annotator = wsag_helper.AgreementAnnotator()
    agreement = _get_agreement(agreement_id)
    violations = _get_agreement_violations(agreement_id, guarantee_name)
    annotator.annotate_agreement(agreement)

    slicename = request.POST.get('slicename')

    paginator = Paginator(violations, 25)  # Show 25 violations per page
    page_num = request.GET.get('page')

    try:
        violation_page = paginator.page(page_num)
    except PageNotAnInteger:
        # If page is not an integer, deliver first page.
        violation_page = paginator.page(1)
    except EmptyPage:
        # If page is out of range (e.g. 9999), deliver first page.
        violation_page = paginator.page(1)

    context = {
        'agreement_id': agreement_id,
        'guarantee_term': agreement.guaranteeterms[guarantee_name],
        'violations': violation_page,
        'agreement': agreement,
        'slicename': slicename,
        'last_violation': violations[-1].actual_value
    }

    context.update(prelude_env)

    return render_to_response('violations_template.html',
                              context,
                              context_instance=RequestContext(request))
Exemple #35
0
    def get_context_data(self, **kwargs):

        page = Page(self.request)

#        pres_view = PresView(page = page)
        pres_view = Raw(page = page,html="<h1>PresView needs to be integrated</h1>")

        context = super(PresViewView, self).get_context_data(**kwargs)

        #context['ALL_STATIC'] = "all_static"
        context['unfold_main'] = pres_view.render(self.request)

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

        prelude_env = page.prelude_env()
        context.update(prelude_env)

        return context
    def get_context_data(self, **kwargs):
        page = Page(self.request)
        page.add_js_files  ( [ "js/common.functions.js" ] )
        platform_query  = Query().get('local:platform').filter_by('disabled', '==', '0').select('platform','platform_longname','gateway_type')
        #platform_query  = Query().get('local:platform').select('platform','platform_longname','gateway_type')
        page.enqueue_query(platform_query)

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

        context = super(PlatformsView, self).get_context_data(**kwargs)
        context['person']   = self.request.user
        context['platforms'] = platformlist.render(self.request)

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

        context.update(page.prelude_env())

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

        return context
def test_plugin_view (request):

    page = Page(request)
    
    page.expose_js_metadata()

    # variables that will get passed to this template
    template_env = {}
    
    slicename='ple.inria.heartbeat'
    main_query = Query.get('resource').filter_by('slice_hrn', '=', slicename).select(['network','type','hrn','hostname','sliver'])
    # without an querytable, this would use use : run_it=False as nothing would listen to the results
    page.enqueue_query (main_query, # run_it=False
                        )

    main_plugin = \
        Stack (
        page=page,
        title='thestack',
        togglable=True,
        domid='stack',
        sons=[ \
        # make sure the 2 things work together
            Messages (
                    page=page,
                    title="Transient Runtime messages",
                    domid="messages-transient",
                    levels='ALL',
                    ),
            QueryTable (
                    page=page,
                    title="Slice %s - checkboxes"%slicename,
                    query=main_query,
                    domid="querytable",
                    checkboxes=True,
                    togglable=True,
                    ),
            Messages (
                    page=page,
                    title="Inline Runtime messages",
                    domid="messages",
                    levels='ALL',
                    togglable=True,
                    transient=False,
                    ),
            Raw (
                    page=page,
                    title="issue messages",
                    togglable=True,
                    html="""
<input type="button" id="bouton" value="Click me" />
""",
                    ),
            ])

    page.add_js_chunks ( """
function issue_debug() {console.log("issue_debug");messages.debug("issue_debug");};
$(function(){$("#bouton").click(issue_debug);});
""")

    # define 'unfold_main' to the template engine
    template_env [ 'unfold_main' ] = main_plugin.render(request)

    # more general variables expected in the template
    template_env [ 'title' ] = 'Single Plugin View' 
    template_env [ 'topmenu_items' ] = topmenu_items_live('plugin', page) 
    template_env [ 'username' ] = the_user (request) 

    # the prelude object in page contains a summary of the requirements() for all plugins
    # define {js,css}_{files,chunks}
    prelude_env = page.prelude_env()
    template_env.update(prelude_env)
    return render_to_response ('view-unfold1.html',template_env,
                               context_instance=RequestContext(request))
Exemple #38
0
    def get_context_data(self, **kwargs):
        page = Page(self.request)
        page.add_js_files  ( [ "js/common.functions.js" ] )
        #platform_query  = Query().get('local:platform').filter_by('disabled', '==', '0').select('platform','platform_longname','gateway_type')
        #platform_query  = Query().get('local:platform').select('platform','platform_longname','gateway_type')
        email_list = []
        status_list = []
        authority_list = []
        config={}

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

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

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

            
        #page.enqueue_query(user_query)

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

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

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

        context.update(page.prelude_env())

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

        return context
    def get_or_post  (self, request, method):
        # Using cache manifold-tables to get the list of authorities faster
        authorities_query = Query.get('authority').select('name', 'authority_hrn')
        authorities = execute_admin_query(request, authorities_query)
        if authorities is not None:
            authorities = sorted(authorities)

        user_query  = Query().get('local:user').select('email')
        user_email = execute_query(self.request, user_query)
        self.user_email = user_email[0].get('email')


        account_query  = Query().get('local:account').select('user_id','platform_id','auth_type','config')
        account_details = execute_query(self.request, account_query)

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

        # getting user_hrn from local:account
        for account_detail in account_details:
            for platform_detail in platform_details:
                if platform_detail['platform_id'] == account_detail['platform_id']:
                    # taking user_hrn only from myslice account
                    # NOTE: we should later handle accounts filter_by auth_type= managed OR user
                    if 'myslice' in platform_detail['platform']:
                        account_config = json.loads(account_detail['config'])
                        user_hrn = account_config.get('user_hrn','N/A')
    
        #user_query  = Query().get('user').select('user_hrn').filter_by('user_hrn','==','$user_hrn')
        #user_hrn = execute_query(self.request, user_query)
        #self.user_hrn = user_hrn[0].get('user_hrn')
        
        
        page = Page(request)
        page.add_css_files ( [ "http://code.jquery.com/ui/1.10.3/themes/smoothness/jquery-ui.css" ] )

        if method == 'POST':
            self.errors = []
    
            # The form has been submitted
            slice_name = request.POST.get('slice_name', '')
            authority_hrn = request.POST.get('authority_hrn', '')
            number_of_nodes = request.POST.get('number_of_nodes', '')
            purpose = request.POST.get('purpose', '')
            email = self.user_email
            #user_hrn = user_hrn
            cc_myself = True
            
            if (authority_hrn is None or authority_hrn == ''):
                self.errors.append('Please, select an authority')
            # What kind of slice name is valid?
            if (slice_name is None or slice_name == ''):
                self.errors.append('Slice Name is mandatory')
    
            if (purpose is None or purpose == ''):
                self.errors.append('Purpose is mandatory')
    
            if not self.errors:
                ctx = {
                    'email': email,
                    'slice_name': slice_name,
                    'authority_hrn': authority_hrn,
                    'number_of_nodes': number_of_nodes,
                    'purpose': purpose,
                }            
                s = PendingSlice(
                    slice_name      = slice_name,
                    user_hrn        = user_hrn,
                    authority_hrn   = authority_hrn,
                    number_of_nodes = number_of_nodes,
                    purpose         = purpose
                )
                s.save()
    
                # The recipients are the PI of the authority
                recipients = authority_get_pi_emails(request, authority_hrn)
    
                #if cc_myself:
                recipients.append('*****@*****.**')
                msg = render_to_string('slice-request-email.txt', ctx)
                #print "email, msg, email, recipients", email , msg, email, recipients 
                send_mail("Onelab user %s requested a slice"%email , msg, email, recipients)
    
                return render(request,'slice-request-ack-view.html') # Redirect after POST
     
        template_env = {
          'topmenu_items': topmenu_items_live('Request a slice', page),
          'errors': self.errors,
          'slice_name': request.POST.get('slice_name', ''),
          'authority_hrn': request.POST.get('authority_hrn', ''),
          'number_of_nodes': request.POST.get('number_of_nodes', ''),
          'purpose': request.POST.get('purpose', ''),
          'email': self.user_email,
          'user_hrn': user_hrn,
          'cc_myself': True,
          'authorities': authorities,
        }
        template_env.update(page.prelude_env ())
        return render(request, 'slicerequest_view.html',template_env)
Exemple #40
0
    def get_or_post(self, request, method):
        errors = []
        # List authorities already in the Registry in order to avoid duplicates
        # Using cache manifold-tables to get the list of authorities faster
        authorities_query = Query.get("authority").select("name", "authority_hrn")
        authorities = execute_admin_query(request, authorities_query)
        if authorities is not None:
            authorities = sorted(authorities)
        root_authorities = sorted([a for a in authorities if "." not in a["authority_hrn"]])

        page = Page(request)
        page.add_js_files(["js/jquery.validate.js", "js/join.js"])
        page.add_css_files(["css/onelab.css", "css/registration.css"])
        page.add_css_files(["http://code.jquery.com/ui/1.10.3/themes/smoothness/jquery-ui.css"])

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

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

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

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

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

            UserModel = get_user_model()

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

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

            if UserModel._default_manager.filter(email__iexact=reg_email):
                errors.append("This email is not usable. Please contact the administrator or try with another email.")
            for user_detail in list_users:
                if user_detail["email"] == reg_email:
                    errors.append("Email already registered in Manifold. Please provide a new email address.")

            # XXX TODO: Factorize with portal/accountview.py
            #            if 'generate' in request.POST['question']:
            from Crypto.PublicKey import RSA

            private = RSA.generate(1024)
            private_key = json.dumps(private.exportKey())
            public = private.publickey()
            public_key = json.dumps(public.exportKey(format="OpenSSH"))

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

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

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

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

                # creating user to manifold local:user
                user_config = (
                    '{"firstname":"' + reg_fname + '", "lastname":"' + reg_lname + '", "authority":"' + reg_auth + '"}'
                )
                user_params = {"email": reg_email, "password": reg_password, "config": user_config, "status": 1}
                manifold_add_user(request, user_params)
                # creating local:account in manifold
                user_id = user_detail["user_id"] + 1  # the user_id for the newly created user in local:user
                account_params = {
                    "platform_id": 5,
                    "user_id": user_id,
                    "auth_type": auth_type,
                    "config": account_config,
                }
                manifold_add_account(request, account_params)

                # Send email
                ctx = {
                    "first_name": reg_fname,
                    "last_name": reg_lname,
                    "authority_hrn": reg_auth,
                    "email": reg_email,
                    "user_hrn": user_hrn,
                    "public_key": public_key,
                }
                recipients = authority_get_pi_emails(request, reg_auth)

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

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

        template_env = {
            "topmenu_items": topmenu_items_live("join", page),
            "errors": errors,
            "pi_first_name": request.POST.get("pi_first_name", ""),
            "pi_last_name": request.POST.get("pi_last_name", ""),
            "pi_email": request.POST.get("pi_email", ""),
            "pi_phone": request.POST.get("pi_phone", ""),
            "pi_password": request.POST.get("pi_password", ""),
            "site_name": request.POST.get("site_name", ""),
            "site_authority": request.POST.get("site_authority", "").lower(),
            "site_abbreviated_name": request.POST.get("site_abbreviated_name", ""),
            "site_url": request.POST.get("site_url", ""),
            "site_latitude": request.POST.get("site_latitude", ""),
            "site_longitude": request.POST.get("site_longitude", ""),
            "address_line1": request.POST.get("address_line1", ""),
            "address_line2": request.POST.get("address_line2", ""),
            "address_line3": request.POST.get("address_line3", ""),
            "address_city": request.POST.get("address_city", ""),
            "address_postalcode": request.POST.get("address_postalcode", ""),
            "address_state": request.POST.get("address_state", ""),
            "address_country": request.POST.get("address_country", ""),
            "root_authority_hrn": request.POST.get("root_authority_hrn", "").lower(),
            "root_authorities": root_authorities,
            "authorities": authorities,
        }
        template_env.update(page.prelude_env())
        return render(request, "join_view.html", template_env)
Exemple #41
0
    def get (self,request, slicename=tmp_default_slice):
    
        page = Page(request)
        page.add_css_files ('css/slice-view.css')
        page.add_js_files  ( [ "js/common.functions.js" ] )
        page.add_js_chunks ('$(function() { messages.debug("sliceview: jQuery version " + $.fn.jquery); });')
        page.add_js_chunks ('$(function() { messages.debug("sliceview: users turned %s"); });'%("on" if do_query_users else "off"))
        page.add_js_chunks ('$(function() { messages.debug("sliceview: leases turned %s"); });'%("on" if do_query_leases else "off"))
        page.add_js_chunks ('$(function() { messages.debug("manifold URL %s"); });'%(ConfigEngine().manifold_url()))

        metadata = page.get_metadata()
        resource_md = metadata.details_by_object('resource')
        resource_fields = [column['name'] for column in resource_md['column']]
    
        user_md = metadata.details_by_object('user')
        user_fields = ['user_hrn'] # [column['name'] for column in user_md['column']]
    
        # TODO The query to run is embedded in the URL
        main_query = Query.get('slice').filter_by('slice_hrn', '=', slicename)
        main_query.select(
                'slice_hrn',
                #'resource.hrn', 'resource.urn', 
                'resource.hostname', 'resource.type', 
                'resource.network_hrn',
                'lease.urn',
                'user.user_hrn',
                #'application.measurement_point.counter'
        )
        # for internal use in the querytable plugin;
        # needs to be a unique column present for each returned record
        main_query_init_key = 'hostname'
    
        query_resource_all = Query.get('resource').select(resource_fields)

        aq = AnalyzedQuery(main_query, metadata=metadata)
        page.enqueue_query(main_query, analyzed_query=aq)
        page.enqueue_query(query_resource_all)
        if do_query_users:
            # Required: the user must have an authority in its user.config
            # XXX Temporary solution
            user_query  = Query().get('local:user').select('config','email')
            user_details = execute_query(self.request, user_query)
            
            # not always found in user_details...
            config={}
#            for user_detail in user_details:
#                #email = user_detail['email']
#                if user_detail['config']:
#                    config = json.loads(user_detail['config'])
#            user_detail['authority'] = config.get('authority',"Unknown Authority")
#
#            if user_detail['authority'] is not None:
#                sub_authority = user_detail['authority'].split('.')
#                root_authority = sub_authority[0]
#                query_user_all = Query.get(root_authority+':user').select(user_fields)
#
#                # XXX TODO this filter doesn't work - to be improved in Manifold
#                #.filter_by('authority.authority_hrn', '=', user_detail['authority'])
#
#                page.enqueue_query(query_user_all)
#            else:
#                print "authority of the user is not in local:user db"
            query_user_all = Query.get('user').select(user_fields)
            #    query_user_all = None
    
        # ... and for the relations
        # XXX Let's hardcode resources for now
        sq_resource    = aq.subquery('resource')
        sq_user        = aq.subquery('user')
        sq_lease       = aq.subquery('lease')
        sq_measurement = aq.subquery('measurement')
        
    
        # Prepare the display according to all metadata
        # (some parts will be pending, others can be triggered by users).
        # 
        # For example slice measurements will not be requested by default...
    
        # Create the base layout (Stack)...
        main_stack = Stack (
            page=page,
            title="Slice %s"%slicename,
            sons=[],
        )
    
        # ... responsible for the slice properties...
    
        # a nice header
        main_stack.insert (
            Raw (page=page,
                 togglable=False, 
                 toggled=True,
                 html="<h2 class='well well-lg'> Slice %s</h2>"%slicename)
        )
    
        # --------------------------------------------------------------------------
        # QueryUpdater (Pending Operations)

        main_stack.insert(QueryUpdater(
            page                = page,
            title               = 'Pending operations',
            query               = main_query,
            togglable           = True,
            # start turned off, it will open up itself when stuff comes in
            toggled             = False, 
            domid               = 'pending',
            outline_complete    = True,
        ))

        # --------------------------------------------------------------------------
        # Filter Resources
       
# turn off for now -- see above
        filter_query_editor = QueryEditor(
            page  = page,
            query = sq_resource, 
            query_all = query_resource_all,
            title = "Select Columns",
            domid = 'select-columns',
            )
        filter_active_filters = ActiveFilters(
            page  = page,
            query = sq_resource,
            title = "Active Filters",
            )
        filters_area = Stack(
            page                = page,
            title               = 'Filter Resources',
            domid               = 'filters',
            sons                = [filter_query_editor, 
                                   filter_active_filters],
            togglable           = True,
            toggled             = 'persistent',
            outline_complete    = True, 
        )
        main_stack.insert (filters_area)

        # --------------------------------------------------------------------------
        # RESOURCES
        # the resources part is made of a Tabs (Geographic, List), 

        resources_as_gmap = GoogleMap(
            page       = page,
            title      = 'Geographic view',
            domid      = 'resources-map',
            # tab's sons preferably turn this off
            togglable  = False,
            query      = sq_resource,
            query_all  = query_resource_all,
            # this key is the one issued by google
            googlemap_api_key = ConfigEngine().googlemap_api_key(),
            # the key to use at init-time
            init_key   = main_query_init_key,
            checkboxes = True,
            # center on Paris
            latitude   = 49.,
            longitude  = 9,
            zoom       = 4,
        )

        resources_as_3dmap = SensLabMap(
            page       = page,
            title      = '3D Map',
            domid      = 'senslabmap',
            query      = sq_resource,
            query_all  = query_resource_all,
        )

        resources_as_list = QueryTable( 
            page       = page,
            domid      = 'resources-list',
            title      = 'List view',
            # this is the query at the core of the slice list
            query      = sq_resource,
            query_all  = query_resource_all,
            init_key     = main_query_init_key,
            checkboxes = True,
            datatables_options = { 
                'iDisplayLength': 25,
                'bLengthChange' : True,
                'bAutoWidth'    : True,
                },
            )

        if insert_grid:
            resources_as_grid = QueryGrid( 
                page       = page,
                domid      = 'resources-grid',
                title      = 'Grid view',
                # this is the query at the core of the slice list
                query      = sq_resource,
                query_all  = query_resource_all,
                init_key     = main_query_init_key,
                checkboxes = True,
                )

        

        #if do_query_leases:
        #    resources_as_scheduler = Scheduler(

        #        page        = page,
        #        title       = 'Scheduler',
        #        domid       = 'scheduler',
        #        query       = sq_resource,
        #        query_all_resources = query_resource_all,
        #        query_lease = sq_lease,

        #        )

        resources_as_scheduler2 = Scheduler2( 
            page       = page,
            domid      = 'scheduler',
            title      = 'Scheduler',
            # this is the query at the core of the slice list
            query = sq_resource,
            query_all_resources = query_resource_all,
            query_lease = sq_lease,
            )

       # with the new 'Filter' stuff on top, no need for anything but the querytable
        resources_as_list_area = resources_as_list 

        resources_sons = [
            resources_as_gmap, 
            resources_as_3dmap,
            resources_as_scheduler2,
            resources_as_list_area,
            ] if do_query_leases else [
            resources_as_gmap, 
            resources_as_3dmap,
            resources_as_list_area,
            resources_as_scheduler2,
            ]
        if insert_grid:
            resources_sons.append(resources_as_grid)

        resources_area = Tabs ( page=page, 
                                domid="resources",
                                togglable=True,
                                title="Resources",
                                outline_complete=True,
                                sons= resources_sons,

                                active_domid = 'scheduler',
                                persistent_active=True,
                                )
        main_stack.insert (resources_area)

        # --------------------------------------------------------------------------
        # USERS
    
        if do_query_users and query_user_all is not None:
            tab_users = Tabs(
                page                = page,
                domid               = 'users',
                outline_complete    = True,
                togglable           = True,
                title               = 'Users',
                active_domid        = 'users-list',
                )
            main_stack.insert(tab_users)
    
            tab_users.insert(QueryTable( 
                page        = page,
                title       = 'Users List',
                domid       = 'users-list',
                # tab's sons preferably turn this off
                togglable   = False,
                # this is the query at the core of the slice list
                query       = sq_user,
                query_all  = query_user_all,
                checkboxes  = True,
                datatables_options = { 
                    'iDisplayLength' : 25,
                    'bLengthChange'  : True,
                    'bAutoWidth'     : True,
                },
            ))

# DEMO    
        # --------------------------------------------------------------------------
        # MEASUREMENTS
        measurements_stats_cpu = SliceStat(
            title = "CPU Usage",
            domid = 'resources-stats-cpu',
            page  = page,
            stats = 'slice',
            key   = 'hrn',
            query = 'none',
            slicename = slicename,
            o = 'cpu'
        )
        
        measurements_stats_mem = SliceStat(
            title = "Memory Usage",
            domid = 'resources-stats-mem',
            page  = page,
            stats = 'slice',
            key   = 'hrn',
            query = 'none',
            slicename = slicename,
            o = 'mem'
        )
        
        measurements_stats_asb = SliceStat(
            title = "Traffic Sent",
            domid = 'resources-stats-asb',
            page  = page,
            stats = 'slice',
            key   = 'hrn',
            query = 'none',
            slicename = slicename,
            o = 'asb'
        )
        
        measurements_stats_arb = SliceStat(
            title = "Traffic Received",
            domid = 'resources-stats-arb',
            page  = page,
            stats = 'slice',
            key   = 'hrn',
            query = 'none',
            slicename = slicename,
            o = 'arb'
        )

        tab_measurements = Tabs ( page=page,
                                domid = "measurements",
                                togglable = True,
                                toggled = 'persistent',
                                title = "Measurements",
                                outline_complete=True,
                                sons = [ measurements_stats_cpu, measurements_stats_mem, measurements_stats_asb, measurements_stats_arb ],
                                active_domid = 'resources-stats-cpu',
                                persistent_active = True,
                                )
        main_stack.insert (tab_measurements)
        
#        tab_measurements = Tabs (
#            page                = page,
#            active_domid        = 'measurements-list',
#            outline_complete    = True,
#            togglable           = True,
#            title               = 'Measurements',
#            domid               = 'measurements',
#        )
#        main_stack.insert(tab_measurements)
#    
#        tab_measurements.insert(QueryTable( 
#            page        = page,
#            title       = 'Measurements',
#            domid       = 'measurements-list',
#            # tab's sons preferably turn this off
#            togglable   = False,
#            # this is the query at the core of the slice list
#            query       = sq_measurement,
#            # do NOT set checkboxes to False
#            # this table being otherwise empty, it just does not fly with dataTables
#            checkboxes  = True,
#            datatables_options = { 
#                'iDisplayLength' : 25,
#                'bLengthChange'  : True,
#                'bAutoWidth'     : True,
#            },
#        ))
#    
#        # --------------------------------------------------------------------------
#        # MESSAGES (we use transient=False for now)
        if insert_messages:
            main_stack.insert(Messages(
                    page   = page,
                    title  = "Runtime messages for slice %s"%slicename,
                    domid  = "msgs-pre",
                    levels = "ALL",
                    # plain messages are probably less nice for production but more reliable for development for now
                    transient = False,
                    # these make sense only in non-transient mode..
                    togglable = True,
                    toggled = 'persistent',
                    outline_complete = True,
                    ))
    
        # variables that will get passed to the view-unfold1.html template
        template_env = {}
        
        # define 'unfold_main' to the template engine - the main contents
        template_env [ 'unfold_main' ] = main_stack.render(request)
    
        # more general variables expected in the template
        template_env [ 'title' ] = '%(slicename)s'%locals()
        # the menu items on the top
        template_env [ 'topmenu_items' ] = topmenu_items_live('Slice', page) 
        # so we can sho who is logged
        template_env [ 'username' ] = the_user (request) 
    
        # don't forget to run the requests
        page.expose_js_metadata()
        # the prelude object in page contains a summary of the requirements() for all plugins
        # define {js,css}_{files,chunks}
        template_env.update(page.prelude_env())

        return render_to_response ('view-unfold1.html',template_env,
                                   context_instance=RequestContext(request))
def dashboard_view(request):

    page = Page(request)

    slices_query = Query.get("slice").select("slice_hrn")
    # old#                                  # xxx filter : should filter on the slices the logged user can see
    # old#                                  # we don't have the user's hrn yet
    # old#                                  # in addition this currently returns all slices anyways
    # old#                                  # filter = ...
    # old#                                  sort='slice_hrn',)
    page.enqueue_query(slices_query)

    main_plugin = Stack(
        page=page,
        title="Putting stuff together",
        sons=[
            QueryCode(page=page, title="Vizualize your query", query=slices_query, toggled=False),
            QuickFilter(
                # we play with this one for demo purposes in dashboard.css
                domid="myquickfilter",
                page=page,
                title="play with filters",
                criterias=quickfilter_criterias,
                toggled=False,
            ),
            SliceList(  # setting visible attributes first
                page=page,
                title="Asynchroneous SliceList",
                header="slices list",
                with_datatables=False,
                # this is the query at the core of the slice list
                query=slices_query,
            ),
        ],
    )

    # variables that will get passed to the view-unfold2.html template
    template_env = {}

    # define 'unfold_main' to the template engine
    template_env["unfold_main"] = main_plugin.render(request)

    # more general variables expected in the template
    template_env["title"] = "Test view for a full request cycle"
    # the menu items on the top
    template_env["topmenu_items"] = topmenu_items_live("dashboard", page)
    # so we can sho who is logged
    template_env["username"] = the_user(request)

    #   ########## add another plugin with the same request, on the RHS pane
    #   will show up in the right-hand side area named 'related'
    related_plugin = SliceList(
        page=page,
        title="Same request, other layout",
        domid="sidelist",
        with_datatables=True,
        header="paginated slices",
        # share the query
        query=slices_query,
    )
    # likewise but on the side view
    template_env["unfold_margin"] = related_plugin.render(request)

    # add our own css in the mix
    # page.add_css_files ( 'css/dashboard.css')

    # the prelude object in page contains a summary of the requirements() for all plugins
    # define {js,css}_{files,chunks}
    prelude_env = page.prelude_env()
    template_env.update(prelude_env)
    return render_to_response("view-unfold2.html", template_env, context_instance=RequestContext(request))
    def get_context_data(self, **kwargs):

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


        user_query  = Query().get('local:user').select('config','email','status')
        user_details = execute_query(self.request, user_query)
        
        # not always found in user_details...
        config={}
        for user_detail in user_details:
            # different significations of user_status
            if user_detail['status'] == 0: 
                user_status = 'Disabled'
            elif user_detail['status'] == 1:
                user_status = 'Validation Pending'
            elif user_detail['status'] == 2:
                user_status = 'Enabled'
            else:
                user_status = 'N/A'
            #email = user_detail['email']
            if user_detail['config']:
                config = json.loads(user_detail['config'])

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

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

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

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

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

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

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


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

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

        # Using cache manifold-tables to get the list of authorities faster
        authorities_query = Query.get('authority').select('name', 'authority_hrn')
        
        #onelab_enabled_query = Query.get('local:platform').filter_by('platform', '==', 'ple').filter_by('disabled', '==', 'False')
        #onelab_enabled = not not execute_admin_query(request, onelab_enabled_query)
        #if onelab_enabled:
        if True:
            print "ONELAB ENABLED"
            #authorities_query = Query.get('ple:authority').select('name', 'authority_hrn').filter_by('authority_hrn', 'included', ['ple.inria', 'ple.upmc', 'ple.ibbtple', 'ple.nitos'])
            # Now using Cache 
        else:
            print "FIREXP ENABLED"

        authorities = execute_admin_query(request, authorities_query)
        if authorities is not None:
            authorities = sorted(authorities)
        # xxx tocheck - if authorities is empty, it's no use anyway
        # (users won't be able to validate the form anyway)

        page = Page(request)
        page.add_js_files  ( [ "js/jquery.validate.js", "js/my_account.register.js" ] )
        page.add_css_files ( [ "css/onelab.css", "css/registration.css" ] )
        page.add_css_files ( [ "http://code.jquery.com/ui/1.10.3/themes/smoothness/jquery-ui.css" ] )

        print 'registration view, method',method

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

        if method == 'POST':
            # We shall use a form here

            #get_email = PendingUser.objects.get(email)
            reg_fname  = request.POST.get('firstname', '')
            reg_lname  = request.POST.get('lastname', '')
            #reg_aff   = request.POST.get('affiliation','')
            reg_auth   = request.POST.get('authority_hrn', '')
            #reg_login  = request.POST.get('login', '')
            reg_email  = request.POST.get('email','').lower()
            #prepare user_hrn 
            split_email = reg_email.split("@")[0] 
            split_email = split_email.replace(".", "_")
            user_hrn = reg_auth + '.' + split_email+ str(randint(1,1000000))
            
            UserModel = get_user_model()

            #POST value validation  
            if (re.search(r'^[\w+\s.@+-]+$', reg_fname)==None):
                errors.append('First Name may contain only letters, numbers, spaces and @/./+/-/_ characters.')
            if (re.search(r'^[\w+\s.@+-]+$', reg_lname) == None):
                errors.append('Last Name may contain only letters, numbers, spaces and @/./+/-/_ characters.')
            # checking in django_db !!
            if PendingUser.objects.filter(email__iexact=reg_email):
                errors.append('Email is pending for validation. Please provide a new email address.')
            if UserModel._default_manager.filter(email__iexact=reg_email): 
                errors.append('This email is not usable. Please contact the administrator or try with another email.')
            for user_detail in user_details:
                if user_detail['email']==reg_email:
                    errors.append('Email already registered in Manifold. Please provide a new email address.')

# XXX TODO: Factorize with portal/accountview.py
            if 'generate' in request.POST['question']:
                from Crypto.PublicKey import RSA
                private = RSA.generate(1024)
                private_key = json.dumps(private.exportKey())
                public  = private.publickey()
                public_key = json.dumps(public.exportKey(format='OpenSSH'))

#                # Generate public and private keys using SFA Library
#                from sfa.trust.certificate  import Keypair
#                k = Keypair(create=True)
#                public_key = k.get_pubkey_string()
#                private_key = k.as_pem()
#                private_key = ''.join(private_key.split())
#                public_key = "ssh-rsa " + public_key
                # Saving to DB
                account_config = '{"user_public_key":'+ public_key + ', "user_private_key":'+ private_key + ', "user_hrn":"'+ user_hrn + '"}'
                auth_type = 'managed'
                #keypair = re.sub("\r", "", keypair)
                #keypair = re.sub("\n", "\\n", keypair)
                #keypair = keypair.rstrip('\r\n')
                #keypair = ''.join(keypair.split())
                #for sending email: removing existing double qoute 
                public_key = public_key.replace('"', '');
            else: 
                up_file = request.FILES['user_public_key']
                file_content =  up_file.read()
                file_name = up_file.name
                file_extension = os.path.splitext(file_name)[1]
                allowed_extension =  ['.pub','.txt']
                if file_extension in allowed_extension and re.search(r'ssh-rsa',file_content):
                    account_config = '{"user_public_key":"'+ file_content + '", "user_hrn":"'+ user_hrn +'"}'
                    account_config = re.sub("\r", "", account_config)
                    account_config = re.sub("\n", "\\n",account_config)
                    account_config = ''.join(account_config.split())
                    auth_type = 'user'
                    # for sending email
                    public_key = file_content
                    public_key = ''.join(public_key.split()) 
                else:
                    errors.append('Please upload a valid RSA public key.')

            #b = PendingUser(first_name=reg_fname, last_name=reg_lname, affiliation=reg_aff, 
            #                email=reg_email, password=request.POST['password'], keypair=keypair)
            #b.save()
            #saving to django db 'portal_pendinguser' table
            if not errors:
                b = PendingUser(
                    first_name    = reg_fname, 
                    last_name     = reg_lname, 
                    #affiliation  = reg_aff,
                    authority_hrn = reg_auth,
                    #login         = reg_login,
                    email         = reg_email, 
                    password      = request.POST['password'],
                    keypair       = account_config,
                    pi            = '',
                )
                b.save()
                # saves the user to django auth_user table [needed for password reset]
                user = User.objects.create_user(reg_email, reg_email, request.POST['password'])
                #creating user to manifold local:user
                user_config = '{"firstname":"'+ reg_fname + '", "lastname":"'+ reg_lname + '", "authority":"'+ reg_auth + '"}'
                user_params = {'email': reg_email, 'password': request.POST['password'], 'config': user_config, 'status': 1}
                manifold_add_user(request,user_params)
                #creating local:account in manifold
                user_id = user_detail['user_id']+1 # the user_id for the newly created user in local:user
                account_params = {'platform_id': 5, 'user_id': user_id, 'auth_type': auth_type, 'config': account_config}
                manifold_add_account(request,account_params)
 
                # Send email
                ctx = {
                    'first_name'    : reg_fname, 
                    'last_name'     : reg_lname, 
                    'authority_hrn' : reg_auth,
                    'email'         : reg_email,
                    'user_hrn'      : user_hrn,
                    'public_key'    : public_key,
                    }
                recipients = authority_get_pi_emails(request,reg_auth)
                # backup email: if authority_get_pi_emails fails
                recipients.append('*****@*****.**')
                
                msg = render_to_string('user_request_email.txt', ctx)
                send_mail("Onelab New User request for %s submitted"%reg_email, msg, '*****@*****.**', recipients)
                return render(request, 'user_register_complete.html') 

        template_env = {
          'topmenu_items': topmenu_items_live('Register', page),
          'errors': errors,
          'firstname': request.POST.get('firstname', ''),
          'lastname': request.POST.get('lastname', ''),
          #'affiliation': request.POST.get('affiliation', ''),
          'authority_hrn': request.POST.get('authority_hrn', ''),
          'email': request.POST.get('email', ''),
          'password': request.POST.get('password', ''),           
          'authorities': authorities,
          }
        template_env.update(page.prelude_env ())
        return render(request, 'registration_view.html',template_env)
    def get_context_data(self, **kwargs):
        page = Page(self.request)
        page.add_js_files  ( [ "js/common.functions.js" ] )

        for key, value in kwargs.iteritems():
            print "%s = %s" % (key, value)       
            if key == "platformname":
                platformname=value
                
        network_query  = Query().get('local:platform')\
            .filter_by('platform', '==', platformname)\
            .select('platform','platform_longname','gateway_type')
        page.enqueue_query(network_query)

        # ListResources of the platform
        metadata = page.get_metadata()
        resource_md = metadata.details_by_object('resource')
        resource_fields = [column['name'] for column in resource_md['column']]
        resources = platformname + ':resource'
        query_resource_all = Query.get(resources).select(resource_fields)
        page.enqueue_query(query_resource_all)
        query_resource_default_fields = Query.get(resources).select('hrn','hostname', 'type','country')
        page.enqueue_query(query_resource_default_fields)

        page.expose_js_metadata()
        networklist = QueryTable(
            page  = page,
            title = 'List',
            domid = 'checkboxes',
            # this is the query at the core of the slice list
            query = network_query,
            query_all = network_query,
            checkboxes = False,
            datatables_options = {
            'iDisplayLength' : 25,
            'bLengthChange'  : True,
            },
        )

#        networklist = SimpleList(
#            title = None,
#            page  = page,
#            key   = 'platform',
#            query = network_query,
#        )
#
        # --------------------------------------------------------------------------
        # RESOURCES
        # for internal use in the querytable plugin;
        # needs to be a unique column present for each returned record
        main_query_init_key = 'hrn'

        # the resources part is made of a Tabs (Geographic, List), 
        resources_as_gmap = GoogleMap(
            page       = page,
            title      = 'Geographic view',
            domid      = 'resources-map',
            # tab's sons preferably turn this off
            togglable  = False,
            query      = query_resource_default_fields,
            query_all  = query_resource_all,
            # this key is the one issued by google
            googlemap_api_key = ConfigEngine().googlemap_api_key(),
            # the key to use at init-time
            init_key   = main_query_init_key,
            checkboxes = False,
            # center on Paris
            latitude   = 49.,
            longitude  = 9,
            zoom       = 4,
        )
        resources_as_3dmap = SensLabMap(
            page       = page,
            title      = '3D Map',
            domid      = 'senslabmap',
            query      = query_resource_default_fields,
            query_all  = query_resource_all,
        )
        resources_as_list = QueryTable(
            page       = page,
            domid      = 'resources-list',
            title      = 'List view',
            # this is the query at the core of the slice list
            query      = query_resource_default_fields,
            query_all  = query_resource_all,
            init_key     = main_query_init_key,
            checkboxes = False,
            datatables_options = {
                'iDisplayLength': 25,
                'bLengthChange' : True,
                'bAutoWidth'    : True,
                },
            )
        resources_sons = [
             resources_as_gmap,
             resources_as_3dmap,
             resources_as_list,
             ]
        resources_area = Tabs ( page=page,
                                domid="resources",
                                togglable=True,
                                title="Resources",
                                outline_complete=True,
                                sons= resources_sons,
                                active_domid = 'resources-map',
                                persistent_active=True,
                                )

        context = super(PlatformView, self).get_context_data(**kwargs)
        context['person']   = self.request.user
        context['networks'] = networklist.render(self.request)
        context['resources'] = resources_area.render(self.request)

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

        context.update(page.prelude_env())

        return context
    def get (self, request, slicename='ple.inria.f14'):

        page=Page(request)
        page.expose_js_metadata()
        metadata = page.get_metadata()
        resource_md = metadata.details_by_object('resource')
        resource_fields = [column['name'] for column in resource_md['column']]

        main_query = Query.get('slice').filter_by('slice_hrn', '=', slicename)
        main_query.select(
                'slice_hrn',
                #'resource.hrn', 
                'resource.hostname', 'resource.type', 
                'resource.network_hrn',
                'lease.urn',
                'user.user_hrn',
                #'application.measurement_point.counter'
        )
        # for internal use in the querygrid plugin;
        # needs to be a unique column present for each returned record
        main_query_init_key = 'hostname'
    
        query_resource_all = Query.get('resource').select(resource_fields)
        
        aq = AnalyzedQuery(main_query, metadata=metadata)
        page.enqueue_query(main_query, analyzed_query=aq)
        page.enqueue_query(query_resource_all)

        sq_resource    = aq.subquery('resource')

        resources_as_list = QueryGrid( 
            page       = page,
            domid      = 'resources-list',
            title      = 'List view',
            # this is the query at the core of the slice list
            query      = sq_resource,
            query_all  = query_resource_all,
            # safer to use 'hrn' as the internal unique key for this plugin
            init_key   = main_query_init_key,
            checkboxes = True,
            datatables_options = { 
                'iDisplayLength': 25,
                'bLengthChange' : True,
                'bAutoWidth'    : True,
                },
            )

        # variables that will get passed to the view-unfold1.html template
        template_env = {}
        
        # define 'unfold_main' to the template engine - the main contents
        template_env [ 'unfold_main' ] = resources_as_list.render(request)
    
        # more general variables expected in the template
        template_env [ 'title' ] = 'simple %(slicename)s'%locals()
        # the menu items on the top
        template_env [ 'topmenu_items' ] = topmenu_items_live('Slice', page) 
        # so we can sho who is logged
        template_env [ 'username' ] = the_user (request) 
    
        # the prelude object in page contains a summary of the requirements() for all plugins
        # define {js,css}_{files,chunks}
        prelude_env = page.prelude_env()
        template_env.update(prelude_env)
        result=render_to_response ('view-unfold1.html',template_env,
                                   context_instance=RequestContext(request))
        return result
    def get_context_data(self, **kwargs):
        # We might have slices on different registries with different user accounts 
        # 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
        # Different registries mean different identities, unless we identify via SFA HRN or have associated the user email to a single hrn

        #messages.info(self.request, 'You have logged in')
        page = Page(self.request)

        print "Dashboard page"
        # Slow...
        #slice_query = Query().get('slice').filter_by('user.user_hrn', 'contains', user_hrn).select('slice_hrn')
        testbed_query  = Query().get('network').select('network_hrn','platform','version')
        # DEMO GEC18 Query only PLE
#        user_query  = Query().get('local:user').select('config','email')
#        user_details = execute_query(self.request, user_query)

        # not always found in user_details...
#        config={}
  #      for user_detail in user_details:
  #          #email = user_detail['email']
  #          if user_detail['config']:
  #              config = json.loads(user_detail['config'])
  #      user_detail['authority'] = config.get('authority',"Unknown Authority")
#
#        print user_detail
#        if user_detail['authority'] is not None:
#            sub_authority = user_detail['authority'].split('.')
#            root_authority = sub_authority[0]
#            slice_query = Query().get(root_authority+':user').filter_by('user_hrn', '==', '$user_hrn').select('user_hrn', 'slice.slice_hrn')
#        else:
        slice_query = Query().get('user').filter_by('user_hrn', '==', '$user_hrn').select('slice.slice_hrn')
        page.enqueue_query(slice_query)
        page.enqueue_query(testbed_query)

        slicelist = SliceList(
            page  = page,
            title = "slices",
            warning_msg = "<a href='../slice_request'>Request Slice</a>",
            query = slice_query,
        )
        testbedlist = TestbedList(
            page  = page,
            title = "testbeds",
            query = testbed_query,
        )
 
        context = super(DashboardView, self).get_context_data(**kwargs)
        context['person']   = self.request.user
        context['testbeds'] = testbedlist.render(self.request) 
        context['slices']   = slicelist.render(self.request)

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

        page.expose_js_metadata()

        # the page header and other stuff
        context.update(page.prelude_env())

        return context
Exemple #48
0
    def get_context_data(self, **kwargs):
        page = Page(self.request)
        
        page.add_js_files  ( [ "js/common.functions.js" ] )

        for key, value in kwargs.iteritems():
            print "%s = %s" % (key, value)       
            if key == "urn":
                resource_urn=value
                
        resource_query  = Query().get('resource')\
            .filter_by('urn', '==', resource_urn)\
            .select('hostname','type','hrn','urn', 'latitude', 'longitude', 'country')
        page.enqueue_query(resource_query)

        page.expose_js_metadata()

        resourcelist = QueryTable(
            page  = page,
            title = 'List',
            domid = 'checkboxes',
            # this is the query at the core of the slice list
            query = resource_query,
            query_all = resource_query,
            checkboxes = False,
            datatables_options = {
            'iDisplayLength' : 25,
            'bLengthChange'  : True,
            },
        )
        resource_as_map = GoogleMap(
            page       = page,
            title      = 'Geographic view',
            domid      = 'resources-map',
            # tab's sons preferably turn this off
            togglable  = True,
            query      = resource_query,
            query_all  = resource_query,
            googlemap_api_key = ConfigEngine().googlemap_api_key(),
            checkboxes = False,
            # center on Paris
            #latitude   = 49.,
            #longitude  = 9,
            #zoom       = 4,
        )
#        resourcelist = SimpleList(
#            title = None,
#            page  = page,
#            key   = 'hrn',
#            query = resource_query,
#        )

        resource_stats = SliceStat(
            title = None,
            page  = page,
            stats = 'node',
            key   = 'hrn',
            query = resource_query
        )

        context = super(ResourceView, self).get_context_data(**kwargs)
        context['person']   = self.request.user
        context['resource'] = resourcelist.render(self.request)
        context['resource_as_map'] = resource_as_map.render(self.request)
        context['resource_stats'] = resource_stats.render(self.request)

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

        context.update(page.prelude_env())

        return context
 def __init__(self, request):
     Page.__init__(self, request)
     self._content = []