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 # 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(self, request, state=None):
try:
site_conf = SiteConf.objects.get(id=1)
except SiteConf.DoesNotExist:
site_conf = SiteConf(id=1)
site_conf.fed_status = 0
site_conf.save()
site_list = None
if site_conf.fed_status == 1:
site_list = Site.objects.filter(status__in=[2
]) # only active sites
env = self.default_env()
env = {
'username': UserAccessProfile(request).username,
# 'topmenu_items' : topmenu_items(None, request),
'fed_status': site_conf.fed_status,
'site_list': site_list
}
if state:
env['state'] = state
elif not env['username']:
env['state'] = None
# use one or two columns for the layout - not logged in users will see the login prompt
env['layout_1_or_2'] = "layout-unfold2.html" if not env[
'username'] else "layout-unfold1.html"
# return render_to_response('home-view.html', env, context_instance=RequestContext(request))
return render(request, 'home-view.html', env)
def _display(self, request):
return render(
request, 'experiment-view.html', {
'topmenu_items': topmenu_items('experiment', request),
'username': UserAccessProfile(request).username,
'title': 'Experiment Tools Information',
})
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 _display(self, request):
return render(
request, 'support-view.html', {
'topmenu_items': topmenu_items('support', request),
'username': UserAccessProfile(request).username,
'title': 'Support',
})
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 _display(self, request):
return render(
request, 'filemanager-view.html', {
'topmenu_items': topmenu_items('filemanager', request),
'username': UserAccessProfile(request).username,
'title': 'User Cloud Disk Manager',
})
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 _display(self, request):
return render(
request, 'tguide-view.html', {
'topmenu_items': topmenu_items('Guide', request),
'username': UserAccessProfile(request).username,
'title': 'Portal Teaching Guide',
})
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, 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 account_process(request):
user_id = ''
usera = UserAccessProfile(request)
user_details = usera.user_obj # get_user_by_email(the_user(request))
if user_details:
user_id = user_details.id
if 'submit_name' in request.POST:
# edited_first_name = request.POST['fname']
# edited_last_name = request.POST['lname']
# config={}
# for user_config in user_details:
# if user_config['config']:
# config = json.loads(user_config['config'])
# config['firstname'] = edited_first_name
# config['lastname'] = edited_last_name
# config['authority'] = config.get('authority','Unknown Authority')
# updated_config = json.dumps(config)
# user_params = {'config': updated_config}
# else: # it's needed if the config is empty
# user_config['config']= '{"firstname":"' + edited_first_name + '", "lastname":"'+ edited_last_name + '", "authority": "Unknown Authority"}'
# #user_params = {'config': user_config['config']}
# updating config local:user in manifold
# manifold_update_user(request, request.user.email,user_params)
# this will be depricated, we will show the success msg in same page
# Redirect to same page with success message
if user_details:
user_details.first_name = request.POST['fname']
user_details.last_name = request.POST['lname']
user_details.save()
messages.success(request,
'Success: First Name and Last Name Updated.')
else:
messages.error(request, 'Error: User not found, Try again')
return HttpResponseRedirect("/portal/account/")
elif 'submit_pass' in request.POST:
# edited_password = request.POST['password']
# for user_pass in user_details:
# user_pass['password'] = edited_password
# updating password in local:user
# user_params = { 'password': user_pass['password']}
# manifold_update_user(request,request.user.email,user_params)
# return HttpResponse('Success: Password Changed!!')
if user_details:
web_user = User.objects.get_by_natural_key(usera.username)
# TODO: change web user password
user_details.password = request.POST['password']
messages.success(request, 'Success: Password Updated.')
else:
messages.error(request, 'Error: User not found, Try again')
return HttpResponseRedirect("/portal/account/")
else:
messages.info(request, 'Under Construction. Please try again later!')
return HttpResponseRedirect("/portal/account/")
def _display(self, request, form):
return render(
request, 'contact-view.html', {
'form': form,
'topmenu_items': topmenu_items('Contact', request),
'username': UserAccessProfile(request).username,
'title': 'Contact Us',
})
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 student_update(request, sid, status_value):
s_id = int(sid)
usera = UserAccessProfile(request)
user_type = usera.user_type
if user_type != 2:
messages.error(request, 'Error: You have not permission to access this page.')
return HttpResponseRedirect("/")
std_obj = MyUser.objects.get(id=s_id)
std_obj.status = status_value
std_obj.save()
messages.success(request, 'Success: Update User.')
return HttpResponseRedirect("/lab/students/")
def experiments_cancel(request, exp):
exp_id = int(exp)
usera = UserAccessProfile(request)
#c_user = get_user_by_email(the_user(request))
user_type = usera.get_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("/")
exp_obj = Experiments.objects.get(id=exp_id)
exp_obj.status = 2
exp_obj.save()
messages.success(request, 'Success: Remove Experiments.')
return HttpResponseRedirect("/lab/experiments/")
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 student_course_cancel(request, cid):
course_id = int(cid)
usera = UserAccessProfile(request)
#c_user = get_user_by_email(the_user(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("/")
course = StudentCourses.objects.get(id=course_id)
remove_course_by_emails(usera.username, course.course_ref.id)
course.delete()
messages.success(request, 'Success: Unroll from Course.')
return HttpResponseRedirect("/lab/my_courses/")
def omf_exe(request):
if not slice_on_time(request, "omf"):
return HttpResponse('eof', content_type="text/plain")
else:
script = request.POST.get('script_text', '')
if not script:
return HttpResponse(request,
'Script Empty',
content_type="text/plain")
username = UserAccessProfile(
request).username # get_username_by_email(the_user(request))
t = exe_script("%s" % script, username)
if t != 0:
return HttpResponse(t, content_type="application/json")
return HttpResponse({"error": "Error, Invalid Script"},
content_type="text/plain")
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 access_token_gen(request):
stype = request.POST.get('stype', None)
if stype is None:
return HttpResponse("error: Please go back and try again",
content_type="text/plain")
if not slice_on_time(request, stype):
return HttpResponse('eof', content_type="text/plain")
else:
r = -1
usera = UserAccessProfile(request)
slice_id = request.session.get('slice_id', None)
slice_id = int(slice_id)
current_slice = None
if stype == "omf":
current_slice = Reservation.objects.get(id=slice_id)
elif stype == "sim":
current_slice = SimReservation.objects.get(id=slice_id)
username = usera.user_obj.first_name + randomStringDigits(6)
password = randomStringDigits(10)
recipients = []
recipients.append(usera.user_obj.email)
ctx = {
'slice_name': current_slice.slice_name,
'slice_duration': current_slice.slice_duration,
'password': password,
'access_token': username,
}
# TODO: qursaan@ call backend here
r = 1
# if cc_myself:
recipients.append(SUPPORT_EMAIL)
msg = render_to_string('access-token-email.txt', ctx)
# print "email, msg, email, recipients", email , msg, email, recipients
send_mail("CRCLAB user %s requested Access Password" % usera.username,
msg, DEFAULT_FROM_EMAIL, recipients)
if r == 1:
return HttpResponse("Success", content_type="text/plain")
return HttpResponse("Fail, Try again!", content_type="text/plain")
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_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_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)