def GET(self, *test_data):
'''
Retrieve and display the pairs of modules that have
at least 1 student who has taken module A
prior to taking module B
'''
is_testing = (len(test_data) > 0)
if is_testing:
module_A = test_data[0]
module_B = test_data[1]
target_ay_sem = test_data[2]
else:
if not session.validate_session():
raise web.seeother('/login')
input_data = model.validate_input(web.input(), ["moduleAandB", "aysem"],
aysem_specific=False, attr_required=False)
target_ay_sem = None
try:
target_ay_sem = input_data.aysem
module_A = input_data.moduleA
module_B = input_data.moduleB
except AttributeError:
module_pairs = None
if target_ay_sem is not None:
module_pairs = model.get_modA_taken_prior_to_modB(target_ay_sem)
# Get a list of all AY-Sems (for users to select)
all_ay_sems = model.get_all_ay_sems()
return RENDER.modulesTakenPriorToOthers("all_pairs", module_pairs, all_ay_sems,
None, None, None, None, target_ay_sem, None)
student_counts = \
model.get_number_of_students_who_took_modA_prior_to_modB(module_A.upper(),
module_B.upper(),
target_ay_sem)
module_B_students = \
model.get_number_of_students_taking_module_in_ay_sem(module_B.upper(),
target_ay_sem)
student_prior_count = 0
for count in student_counts:
count = count[1]
student_prior_count += count
if is_testing:
return [student_counts, student_prior_count, module_B_students]
else:
return RENDER.modulesTakenPriorToOthers("specific_pair", None, None, student_counts,
student_prior_count, module_A.upper(),
module_B.upper(), target_ay_sem,
module_B_students)
def GET(self):
'''
Handles the loading of the 'Edit General Module Info' page
'''
input_data = model.validate_input(web.input(), ["code"])
module_code = input_data.code
module_info = model.get_module(module_code)
if module_info is None:
return RENDER.notfound("Module " + module_code + " does not exist in the system.")
preclusions = model.get_preclusion_as_string(module_code)
prerequisites = model.get_prerequisite_as_string(module_code)
return RENDER.moduleEdit(module_info, preclusions, prerequisites)
def GET(self):
'''
Retrieve and display the list of modules taken before
internship and the number of students who has taken those
modules.
'''
if not session.validate_session():
raise web.seeother('/login')
ay_sem_of_interest = None
#see if the user has already requested a search
input_data = model.validate_input(web.input(), ["aysem"],
aysem_specific=False,
attr_required=False)
try:
ay_sem = input_data.aysem
ay_sem_of_interest = ay_sem
except AttributeError:
ay_sem_of_interest = self.CURRENT_SEM
if not self.validateAYSem(ay_sem_of_interest):
ay_sem_of_interest = "AY 16/17 Sem 1"
modules_before_internship = model.get_mod_before_intern(
ay_sem_of_interest)
return RENDER.modulesTakenPriorToInternship(modules_before_internship,
self.AVAILABLE_AY_SEM,
ay_sem_of_interest)
def GET(self):
'''
Renders the non-overlapping modules page if users requested
for the page through the GET method.
'''
if not session.validate_session():
raise web.seeother('/login')
ay_sem_of_interest = None
#see if the user has already requested a search
input_data = model.validate_input(web.input(), ["aysem"],
aysem_specific=False,
attr_required=False)
try:
ay_sem = input_data.aysem
ay_sem_of_interest = ay_sem
except AttributeError:
ay_sem_of_interest = self.CURRENT_SEM
if not self.validateAYSem(ay_sem_of_interest):
ay_sem_of_interest = "AY 16/17 Sem 1"
lst_of_independ_mods = model.get_mods_no_one_take(ay_sem_of_interest)
return RENDER.nonOverlappingModules(lst_of_independ_mods,
self.AVAILABLE_AY_SEM,
ay_sem_of_interest)
def GET(self):
'''
render page with add module form
'''
if not session.validate_session():
raise web.seeother('/login')
return RENDER.addModules()
def GET(self):
'''
This function is called when /starredModules is accessed.
'''
if not session.validate_session():
raise web.seeother('/login')
else:
starred_module_infos = model.get_starred_modules(web.cookies().get('user'))
return RENDER.starredModulesListing(starred_module_infos)
def GET(self):
'''
Handles the display of the Delete Module page
'''
if not session.validate_session():
raise web.seeother('/login')
else:
module_infos = model.get_new_modules()
return RENDER.deleteModule(module_infos)
def GET(self):
'''
This function is called when the '/modules' page (moduleListing.html) is loaded
If user is not logged in, they are redirected to the login page.
'''
if not session.validate_session():
raise web.seeother('/login')
else:
module_infos = model.get_all_modules_and_focus()
aggregated_modules = self.aggregate_modules_for_focus(module_infos)
return RENDER.moduleListing(aggregated_modules)
def GET(self):
'''
Handles the loading of the 'Edit Module Prerequisites' page.
'''
if not session.validate_session():
raise web.seeother('/login')
else:
input_data = model.validate_input(web.input(), ["code"])
module_code = input_data.code.upper()
prerequisites = model.get_prerequisite_units(module_code)
return RENDER.moduleEditPrerequisite(module_code, prerequisites)
def GET(self):
'''
gets the page with code and ay-sem
'''
if not session.validate_session():
raise web.seeother('/login')
input_data = model.validate_input(web.input(), ["code", "aysem"])
module_code = input_data.code
ay_sem = input_data.aysem
student_list = model.get_list_students_take_module(module_code, ay_sem)
return RENDER.studentsAffectedByModule(module_code, ay_sem, student_list)
def GET(self):
'''
Renders the list of modules with specific class size page if users
requested for the page through the GET method.
'''
if not session.validate_session():
raise web.seeother('/login')
input_data = model.validate_input(web.input(), ["aysem"],
aysem_specific=False,
attr_required=False)
try:
# Search request by user
ay_sem_of_interest = input_data.aysem
lower_range_class_size = input_data.lowerClassSize
higher_range_class_size = input_data.higherClassSize
except AttributeError:
# Loading the page without sufficient data (first time load page)
current_aysem = model.get_current_ay_sem()
return RENDER.moduleSpecificSize(self.all_ay_sems, None,
current_aysem, None, None)
if not self.is_valid_range(lower_range_class_size,
higher_range_class_size):
return Outcome().POST("mods-specific-size-range", False, None)
else:
# All inputs are valid
# Convert unicode to int
lower_range = int(lower_range_class_size)
higher_range = int(higher_range_class_size)
list_of_mods = \
model.get_mod_specified_class_size(ay_sem_of_interest, lower_range,
higher_range)
return RENDER.moduleSpecificSize(self.all_ay_sems, list_of_mods,
ay_sem_of_interest, lower_range,
higher_range)
def GET(self):
'''
Handles the loading of the 'Edit Specific Module Info' page
'''
input_data = model.validate_input(web.input(), ["code", "aysem"], is_future=True)
module_code = input_data.code
ay_sem = input_data.aysem
module_ay_sem_info_handler = IndividualModule()
module_ay_sem_info_handler.load_mounting_info(module_code, ay_sem)
mounting_value = module_ay_sem_info_handler.get_mounting_status()
quota = module_ay_sem_info_handler.get_quota()
return RENDER.mountingEdit(module_code, ay_sem, mounting_value, quota)
def GET(self):
'''
renders list of modules that overlapps with this module
'''
if not session.validate_session():
raise web.seeother('/login')
data_input = model.validate_input(web.input(), ["code", "aysem"],
aysem_specific=False)
code = data_input.code
try:
aysem = data_input.aysem
if aysem == "":
raise web.seeother('/overlappingWithModule?code=' + code)
else:
lst_of_mods = model.get_mod_taken_together_with_mod_and_aysem(
code, aysem)
return RENDER.overlappingWithModule(code, aysem, lst_of_mods,
True)
except AttributeError:
aysem = 'All Semesters'
lst_of_mods = model.get_mod_taken_together_with(code)
return RENDER.overlappingWithModule(code, aysem, lst_of_mods,
False)
def GET(self):
'''
Renders the dummy query page if users requested
for the page through the GET method.
'''
if not session.validate_session():
raise web.seeother('/login')
table_of_year_of_study_with_count = model.get_num_students_by_yr_study(
)
table_of_focus_area_with_count = model.get_num_students_by_focus_areas(
)
return RENDER.studentEnrollment(table_of_year_of_study_with_count,
table_of_focus_area_with_count)
def GET(self):
'''
Renders the 'Edit All Mountings and Quotas' page if users requested
for the page through the GET method.
'''
if not session.validate_session():
raise web.seeother('/login')
# Currently, tentative mounting will be shown for the next AY
selected_ay = model.get_next_ay(model.get_current_ay())
tenta_mounting_handler = Tentative()
tenta_mounting_handler.populate_module_code_and_name()
tenta_mounting_handler.populate_module_ay_sem_data(selected_ay)
full_mounting_plan = tenta_mounting_handler.full_mounting_plan
full_mounting_plan = model.replace_empty_quota_with_symbols(full_mounting_plan)
return RENDER.editAll(selected_ay, full_mounting_plan)
def POST(self):
'''
called from search with form
'''
# Input data will have valid inputs as function is called from submit button
input_data = model.validate_input(web.input(), ["aysem"])
try:
ay_sem_of_interest = input_data.aysem
lower_range_class_size = input_data.lowerClassSize
higher_range_class_size = input_data.higherClassSize
except AttributeError:
error = RENDER.notfound(
'Please do not tamper with our html forms. Thank you! ;)')
raise web.notfound(error)
webpage_to_redirect = "/moduleSpecificSize?aysem=" + ay_sem_of_interest + \
"&lowerClassSize=" + lower_range_class_size + \
"&higherClassSize=" + higher_range_class_size
raise web.seeother(webpage_to_redirect)
def GET(self):
'''
This function is called when the '/' page (index.html) is loaded
If user is not logged in, they are redirected to the login page.
'''
if not session.validate_session():
raise web.seeother('/login')
else:
current_ay_with_current_date = model.get_current_ay_sem()[0:8]
current_database_ay = model.get_current_ay()
to_migrate_db = False
if current_ay_with_current_date != current_database_ay:
to_migrate_db = True
# [NOTE] for debugging purposes, comment out this line when done.
# to_migrate_db = True
return RENDER.index(need_migration=to_migrate_db)
def GET(self):
'''
This function is called when the database migration page is loaded
If user is not logged in, they are redirected to the login page.
'''
if not session.validate_session():
raise web.seeother('/login')
else:
current_ay_with_current_date = model.get_current_ay_sem()[0:8]
current_database_ay = model.get_current_ay()
if current_ay_with_current_date == current_database_ay:
# pass # [NOTE] uncomment out this line for debugging purposes
raise web.seeother(
"/") # [NOTE] comment out this line for debugging purposes
next_ay = model.get_next_ay(current_database_ay)
future_ay = model.get_next_ay(next_ay)
return RENDER.databaseMigrate(current_database_ay, next_ay,
future_ay)
def GET(self):
'''
Retrieve and render all the info of a module mounting
'''
if not session.validate_session():
raise web.seeother('/login')
input_data = model.validate_input(web.input(), ["code", "aysem"])
module_code = input_data.code
ay_sem = input_data.aysem
# Get module's name, description, MC and status
module_info = model.get_module(module_code)
# Get mounting status, quota and number of students taking
self.load_mounting_info(module_code, ay_sem)
student_count = model.get_number_of_students_taking_module_in_ay_sem(
module_code, ay_sem)
# Check if the selected AY-Sem is in the current AY
# (To determine whether to display the 'Edit Specific Info' button)
is_future_ay = not self.is_current_ay
# Check if module is starred
is_starred = model.is_module_starred(module_code,
web.cookies().get('user'))
# Get the year of study and focus area distriubtions of students taking the module
# (To be rendered as charts)
self.load_focus_areas()
self.load_student_enrollments(module_code, ay_sem)
all_ay_sems = model.get_all_ay_sems()
all_future_ay_sems = model.get_all_future_ay_sems()
return RENDER.individualModuleInfo(
module_info, all_ay_sems, all_future_ay_sems, is_future_ay, ay_sem,
self.mounting_status, self.quota, student_count, is_starred,
self.focus_areas, self.focus_area_acronyms,
self.student_year_counts, self.focus_area_counts)
def GET(self):
'''
Renders the modules page if users requested
for the page through the GET method.
'''
if not session.validate_session():
raise web.seeother('/login')
input_data = model.validate_input(web.input(), ["aysem"],
aysem_specific=False,
attr_required=False)
try:
target_ay_sem = input_data.aysem
except AttributeError:
target_ay_sem = model.get_current_ay_sem()
lst_of_mods = model.get_all_mods_taken_together(aysem=target_ay_sem)
# Get a list of all AY-Sems (for users to select)
all_ay_sems = model.get_all_ay_sems()
return RENDER.overlappingModules(lst_of_mods, all_ay_sems,
target_ay_sem)
def GET(self, to_render=True, logged_in=False):
'''
Renders the tentative mounting page if users requested
for the page through the GET method.
'''
if not session.validate_session() and not logged_in:
raise web.seeother('/login')
# Currently, tentative mounting will be shown for the next AY
selected_ay = model.get_next_ay(model.get_current_ay())
self.populate_module_code_and_name()
self.populate_module_ay_sem_data(selected_ay)
full_mounting_plan = model.replace_empty_quota_with_symbols(
self.full_mounting_plan)
if to_render:
return RENDER.moduleMountingTentative(selected_ay,
full_mounting_plan)
else:
self.full_mounting_plan = full_mounting_plan
def GET(self):
'''
Retrieve and render all the info of a module
'''
if not session.validate_session():
raise web.seeother('/login')
input_data = model.validate_input(web.input(), ["code"])
module_code = input_data.code
# Get module's name, description, MC and status
module_info = model.get_module(module_code)
# Get mounting status, quota and number of students taking
self.load_fixed_mounting_plan(module_code)
self.load_tenta_mounting_plan(module_code)
number_of_student_planning = model.get_number_students_planning(
module_code)
# Get module's prereqs and preclusions
prereq_string = model.get_prerequisite_as_string(module_code)
preclude_string = model.get_preclusion_as_string(module_code)
# Check if module is starred
is_starred = model.is_module_starred(module_code,
web.cookies().get('user'))
all_ay_sems = model.get_all_ay_sems()
all_future_ay_sems = model.get_all_future_ay_sems()
target_ay_sem = None
#get html of overlapping modules template
return RENDER.viewModule(module_info, all_ay_sems, all_future_ay_sems,
target_ay_sem, self.fixed_mounting_plan,
self.tenta_mounting_plan,
number_of_student_planning, is_starred,
prereq_string, preclude_string)
def GET(self, to_render=True, logged_in=False):
'''
Renders the fixed mounting page if users requested
for the page through the GET method.
'''
if not session.validate_session() and not logged_in:
raise web.seeother('/login')
self.populate_module_code_and_name()
self.populate_module_ay_sem_data()
current_ay = model.get_current_ay()
full_mounting_plan = self.full_mounting_plan
# New modules will not be displayed in fixed mounting
full_mounting_plan = [
subplan for subplan in full_mounting_plan
if subplan[8].rstrip() == "Active"
]
full_mounting_plan = model.replace_empty_quota_with_symbols(
full_mounting_plan)
if to_render:
return RENDER.moduleMountingFixed(current_ay, full_mounting_plan)
else:
self.full_mounting_plan = full_mounting_plan
def GET(self):
'''
This function is called when /login is accessed.
'''
return RENDER.login(session.validate_session())
def POST(self, *received_data):
'''
POST method will check the type of action executed by the user,
and display the corresponding message based on the execution's outcome.
'''
if received_data is not None:
data = received_data
action = data[0]
outcome = data[1]
module_code = data[2]
outcome_message = None
redirect_page = None
if action == "add_module":
if outcome is True:
outcome_message = "Module " + module_code + " has been added successfully!"
redirect_page = "/viewModule?code="+module_code
else:
if module_code is None:
outcome_message = "Error: failed to add module!"
else:
outcome_message = "Error: " + module_code + " is an existing module!"
redirect_page = "/modules"
elif action == "edit_module":
if outcome is True:
outcome_message = "Module " + module_code + " has been edited successfully!"
redirect_page = "/viewModule?code="+module_code
else:
outcome_message = "Error: Failed to edit module."
if module_code is None:
redirect_page = "/modules"
else:
redirect_page = "/viewModule?code="+module_code
elif action == "invalid_input":
outcome_message = "Invalid input for module name/code/MCs/description"
redirect_page = "/"
elif action == "edit_mounting":
ay_sem = data[3]
if outcome is True:
outcome_message = "Module " + module_code + " has been edited successfully!"
redirect_page = "individualModuleInfo?code="+module_code+"&aysem="+\
ay_sem.replace(' ', '+').replace('/', '%2F')
else:
outcome_message = "Error: Failed to edit module."
if module_code is None or ay_sem is None:
redirect_page = "/modules"
else:
redirect_page = "individualModuleInfo?code="+module_code+"&aysem="+\
ay_sem.replace(' ', '+').replace('/', '%2F')
elif action == "edit_all_mountings_and_quotas":
if outcome is True:
outcome_message = "Modules have been edited successfully!"
else:
outcome_message = "Error: Failed to edit modules."
redirect_page = "/editAll"
elif action == "restore_module":
if outcome is True:
outcome_message = "Module " + module_code + " has been restored successfully!"
redirect_page = "/viewModule?code="+module_code
else:
outcome_message = "Error: Failed to restore module."
redirect_page = "/modifiedModules"
elif action == "delete_module":
if outcome is True:
outcome_message = "Module " + module_code + " has been deleted successfully!"
redirect_page = "/deleteModule"
else:
outcome_message = "Error: Failed to delete module. "
redirect_page = "/deleteModule"
if module_code is not None:
if outcome == "has_mounting":
outcome_message += "Module " + module_code + " has " +\
"mountings that refer to it. " +\
"Please remove all mountings before deleting " +\
"the module."
redirect_page = "/viewModule?code=" + module_code
elif outcome == "is_starred":
outcome_message += "Module " + module_code + " is a starred module. " +\
"Please unstar the module before deleting " +\
"the module."
redirect_page = "/viewModule?code=" + module_code
elif action == "create_user":
if outcome is True:
outcome_message = "Your account has been created successfully. " +\
"Please proceed to login."
redirect_page = "/login"
elif outcome == "taken":
outcome_message = "The username has been taken. " +\
"Please register with a different username."
redirect_page = "/register"
else:
outcome_message = "Error: Invalid UserID/password. " +\
"Please check that your UserID/password is not more than " +\
"20 characters long and does not contain special characters."
redirect_page = "/register"
elif action == "login_user":
outcome_message = "Login credentials are empty or incorrect. " +\
"Please try again."
redirect_page = "/login"
elif action == "module_taken_prior":
outcome_message = "Error: Module code " + module_code + " does not exist! "
redirect_page = "/moduleTakenPriorToOthers"
elif action == "non-overlapping-mods":
outcome_message = "The AY-Semester you specified does not exist!"
redirect_page = "/nonOverlappingModules"
elif action == "mods-specific-size-aysem":
outcome_message = "The AY-Semester you specified does not exist!"
redirect_page = "/moduleSpecificSize"
elif action == "mods-specific-size-range":
outcome_message = "You have specified an invalid range!"
redirect_page = "/moduleSpecificSize"
elif action == "mods-before-internship":
outcome_message = "The AY-Semester you specified does not exist!"
redirect_page = "/moduleTakenPriorToInternship"
elif action == "migrate-database":
if outcome is True:
outcome_message = "The database has been successfully migrated to the new AY."
else:
outcome_message = "The database migration could not be performed. " +\
"Please contact the system administrator."
redirect_page = "/"
elif action == "back-to-listing":
outcome_message = "The module you want to view has been deleted by another user!"
redirect_page = "/"
else:
outcome_message = "unknown error has occured with action " + action
return RENDER.outcome(outcome_message, redirect_page)
def GET(self, *test_data):
'''
Renders the oversubscribed modules page if users requested
for the page through the GET method.
'''
if test_data:
target_ay_sem = test_data[0]
else:
if not session.validate_session():
raise web.seeother('/login')
input_data = model.validate_input(web.input(), ["aysem"],
aysem_specific=False,
attr_required=False)
try:
target_ay_sem = input_data.aysem
except AttributeError:
target_ay_sem = model.get_current_ay_sem()
all_ay_sems = model.get_all_ay_sems()
#list_of_oversub_mod = model.get_oversub_mod()
list_of_oversub_mod = []
current_ay = model.get_current_ay()
if target_ay_sem[0:8] == current_ay:
fixed_mounting_handler = Fixed()
fixed_mounting_handler.GET(to_render=False, logged_in=True)
full_mounting_plan = fixed_mounting_handler.full_mounting_plan
if target_ay_sem[9:15] == "Sem 1":
for subplan in full_mounting_plan:
module_code = subplan[0]
module_name = subplan[1]
sem1_quota = subplan[4]
sem1_num_students = subplan[6]
if ((sem1_quota != '?' and sem1_quota != '-') \
and sem1_num_students > sem1_quota) \
or ((sem1_quota == '?' or sem1_quota == '-') and sem1_num_students > 0):
if sem1_quota == '?' or sem1_quota == '-':
oversub_amount = sem1_num_students
else:
oversub_amount = sem1_num_students - sem1_quota
list_of_oversub_mod.append(
(module_code, module_name, target_ay_sem,
sem1_quota, sem1_num_students, oversub_amount))
else:
for subplan in full_mounting_plan:
module_code = subplan[0]
module_name = subplan[1]
sem2_quota = subplan[5]
sem2_num_students = subplan[7]
if ((sem2_quota != '?' and sem2_quota != '-') \
and sem2_num_students > sem2_quota) \
or ((sem2_quota == '?' or sem2_quota == '-') and sem2_num_students > 0):
if sem2_quota == '?' or sem2_quota == '-':
oversub_amount = sem2_num_students
else:
oversub_amount = sem2_num_students - sem2_quota
list_of_oversub_mod.append(
(module_code, module_name, target_ay_sem,
sem2_quota, sem2_num_students, oversub_amount))
else:
tenta_mounting_handler = Tentative()
tenta_mounting_handler.GET(to_render=False, logged_in=True)
full_mounting_plan = tenta_mounting_handler.full_mounting_plan
if target_ay_sem[9:15] == "Sem 1":
for subplan in full_mounting_plan:
module_code = subplan[0]
module_name = subplan[1]
sem1_quota = subplan[4]
sem1_num_students = subplan[6]
if ((sem1_quota != '?' and sem1_quota != '-') \
and sem1_num_students > sem1_quota) \
or ((sem1_quota == '?' or sem1_quota == '-') and sem1_num_students > 0):
if sem1_quota == '?' or sem1_quota == '-':
oversub_amount = sem1_num_students
else:
oversub_amount = sem1_num_students - sem1_quota
list_of_oversub_mod.append(
(module_code, module_name, target_ay_sem,
sem1_quota, sem1_num_students, oversub_amount))
else:
for subplan in full_mounting_plan:
module_code = subplan[0]
module_name = subplan[1]
sem2_quota = subplan[5]
sem2_num_students = subplan[7]
if ((sem2_quota != '?' and sem2_quota != '-') \
and sem2_num_students > sem2_quota) \
or ((sem2_quota == '?' or sem2_quota == '-') and sem2_num_students > 0):
if sem2_quota == '?' or sem2_quota == '-':
oversub_amount = sem2_num_students
else:
oversub_amount = sem2_num_students - sem2_quota
list_of_oversub_mod.append(
(module_code, module_name, target_ay_sem,
sem2_quota, sem2_num_students, oversub_amount))
if not test_data:
return RENDER.oversubscribedModules(list_of_oversub_mod,
all_ay_sems, target_ay_sem)
else:
return list_of_oversub_mod
def GET(self):
'''
This function is called when /register is accessed.
'''
return RENDER.register()
def validate_input(input_data,
input_types,
is_future=False,
aysem_specific=True,
attr_required=True,
show_404=True):
'''
Validates that the GET input data (in the URL) is valid.
input_types indicate the list of data types to validate.
e.g. if GET input contains 'code' and 'aysem', then input_types = ["code", "aysem"]
An input is considered valid if:
1) The value was specified and
2) The value exists in the system
If any input is invalid, return 404 page (by default).
Depending on the circumstances, optional arguments may be passed into the function:
is_future:
Set to True if want to ensure that AY-Sem is in a future AY
(if AY-Sem is not required at all, then ignore this argument)
aysem_specific:
Set to True if the AY-Sem attribute is mandatory, False if it is optional
(if AY-Sem is not required at all, then ignore this argument)
attr_required:
Set to True if at least one attribute is required
Set to False if it is acceptable to have no input data
show_404:
Set to False if don't want to return 404 page (function will return False instead)
'''
from app import RENDER
if attr_required is False and len(input_data) == 0:
return input_data
for input_type in input_types:
if input_type == "code":
try:
module_code = input_data.code
except AttributeError:
if show_404:
error = RENDER.notfound('Module code is not specified')
raise web.notfound(error)
else:
return False
module_exist = database.is_existing_module(module_code.upper())
if not module_exist:
if show_404:
error = RENDER.notfound('Module code "' + module_code +\
'" does not exist in our system')
raise web.notfound(error)
else:
return False
else:
input_data.code = module_code.upper()
elif input_type == "aysem":
try:
ay_sem = input_data.aysem
if ay_sem == "":
raise AttributeError
except AttributeError:
if aysem_specific:
if show_404:
error = RENDER.notfound('AY-Semester is not specified')
raise web.notfound(error)
else:
return False
else:
continue
if is_future:
valid_aysem = is_aysem_in_system_and_is_future(ay_sem)
else:
valid_aysem = is_aysem_in_system(ay_sem)
if not valid_aysem:
if is_future:
error = RENDER.notfound('AY-Semester "' + ay_sem +\
'" does not exist in our system,' +\
' or is not in a future AY')
else:
error = RENDER.notfound('AY-Semester "' + ay_sem +\
'" does not exist in our system')
if show_404:
raise web.notfound(error)
else:
return False
else:
input_data.aysem = valid_aysem
elif input_type == "modify_type" or input_type == "restore_type":
try:
if input_type == "modify_type":
info_type = input_data.modifyType
else:
info_type = input_data.restoreType
except AttributeError:
if input_type == "modify_type":
error = RENDER.notfound('Modify type is not specified')
else:
error = RENDER.notfound('Restore type is not specified')
raise web.notfound(error)
valid_info_type = info_type.upper() == "QUOTA" or \
info_type.upper() == "MOUNTING" or \
info_type.upper() == "MODULEDETAILS"
if not valid_info_type:
if input_type == "modify_type":
error = RENDER.notfound('Modify type "' + info_type +\
'" is not recognised by the system')
else:
error = RENDER.notfound('Restore type "' + info_type +\
'" is not recognised by the system')
raise web.notfound(error)
elif input_type == "moduleAandB":
try:
moduleA_code = input_data.moduleA
is_moduleA_specified = True
except AttributeError:
is_moduleA_specified = False
try:
moduleB_code = input_data.moduleB
is_moduleB_specified = True
except AttributeError:
is_moduleB_specified = False
if (is_moduleA_specified and not is_moduleB_specified) or \
(not is_moduleA_specified and is_moduleB_specified):
error = RENDER.notfound(
"1 out of 2 module codes is not specified")
raise web.notfound(error)
elif not is_moduleA_specified and not is_moduleB_specified:
continue
module_exist = database.is_existing_module(moduleA_code.upper())
if not module_exist:
error = RENDER.notfound('Module code "' + moduleA_code +\
'" does not exist in our system')
raise web.notfound(error)
else:
input_data.moduleA = moduleA_code.upper()
module_exist = database.is_existing_module(moduleB_code.upper())
if not module_exist:
error = RENDER.notfound('Module code "' + moduleB_code +\
'" does not exist in our system')
raise web.notfound(error)
else:
input_data.moduleB = moduleB_code.upper()
return input_data
def GET(self):
'''
Renders the modified modules page if users requested
for the page through the GET method.
'''
if not session.validate_session():
raise web.seeother('/login')
# User can select the type of modified information they want to see
# By default, the page will show ALL modified modules
modify_type = None
module_code = None
input_data = model.validate_input(web.input(), ["code", "modify_type"],
attr_required=False)
try:
modify_type = input_data.modifyType
except AttributeError:
modify_type = None
try:
module_code = input_data.code
except AttributeError:
module_code = None
# If module code is specified, only return data for the specified module
modified_modules_summary = []
modified_modules_mounting = []
modified_modules_quota = []
modified_modules_details = []
modified_modules = []
if module_code is not None:
if modify_type.lower() == "mounting":
modified_modules = self.get_modules_with_modified_mounting()
module = [
module for module in modified_modules
if module[0] == module_code
]
elif modify_type.lower() == "quota":
modified_modules = self.get_modules_with_modified_quota()
module = [
module for module in modified_modules
if module[0] == module_code
]
elif modify_type.lower() == "moduledetails":
module = None
modified_modules = self.get_modules_with_modified_details()
module = None
for mm in modified_modules:
if mm[0][0] == module_code:
module = mm
break
modified_modules = module
# Else return all 4 modification tables, for all the modified modules
else:
modified_modules_summary = self.get_all_modified_modules()
modified_modules_mounting = self.get_modules_with_modified_mounting(
)
modified_modules_quota = self.get_modules_with_modified_quota()
modified_modules_details = self.get_modules_with_modified_details()
return RENDER.moduleModified(modify_type, modified_modules_summary,
modified_modules_mounting,
modified_modules_quota,
modified_modules_details, module_code,
modified_modules)
