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
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)
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
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) 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
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 = {}
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)
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)
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)
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
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
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
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
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 un_complete_page(request): page = Page(request) return render( request, 'uncomplete.html', { #'topmenu_items': topmenu_items('test_page', request), 'title': 'TEST PAGE', })
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
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
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)
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
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)
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)
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)
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"
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
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)
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))
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
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
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
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))
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))
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)
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)
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
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 = []