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_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, 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)
# 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(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_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_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_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)
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_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):
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):
# 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_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 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)
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_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))
get_count_active_slice(c_user=c_user, username=usera.session_username)
pending_list_1 = Reservation.objects.filter(
user_ref=c_user,
username=usera.session_username,
status=ReservationStatus.get_pending())
active_list_1 = Reservation.objects.filter(
user_ref=c_user,
username=usera.session_username,
status=ReservationStatus.get_active())
pending_list_2 = SimReservation.objects.filter(
user_ref=c_user,
username=usera.session_username,
status=ReservationStatus.get_pending())
active_list_2 = SimReservation.objects.filter(
user_ref=c_user,
username=usera.session_username,
status=ReservationStatus.get_active())
context = super(SliceCurrentView, self).get_context_data(**kwargs)
context['current_list_1'] = pending_list_1
context['active_list_1'] = active_list_1
context['current_list_2'] = pending_list_2
context['active_list_2'] = active_list_2
context['time_now'] = timezone.now()
# XXX This is repeated in all pages
# more general variables expected in the template
context['title'] = 'Reservation Panel'
# the menu items on the top
# context['topmenu_items'] = topmenu_items('Reservation Status', page.request) # @qursaan change from _live
# so we can sho who is logged
context['username'] = usera.username # the_user(self.request)
# context ['firstname'] = config['firstname']
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['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_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, slicename):
"""
"""
# Page rendering
page = Page(request)
page.add_js_files(["js/jquery-ui.js"])
page.add_css_files(["css/jquery-ui.css"])
errors = []
slice_name = ''
template_env = {
'theme': self.theme,
'section': "Slice request",
'slicename': slicename,
'request': request,
}
template_env.update(page.prelude_env())
return render_to_response(self.template,
template_env,
context_instance=RequestContext(request))
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_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_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)
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
