def POST(self, *test_data):
'''
Handles the restoration of module info
'''
if test_data: # for testing purposes
input_data = test_data[0]
else:
input_data = model.validate_input(web.input(),
["code", "restore_type"])
module_code = input_data.code
restore_type = input_data.restoreType
if restore_type.lower() == "quota":
model.validate_input(input_data, ["aysem"])
ay_sem = input_data.aysem
quota = input_data.quota
if quota == "":
quota = None
outcome = model.update_quota(module_code, ay_sem, quota)
if not test_data:
return Outcome().POST("restore_module", outcome, module_code)
elif restore_type.lower() == "mounting":
model.validate_input(input_data, ["aysem"])
target_ay_sem = input_data.aysem
mounting_change = int(input_data.mountingChange)
outcome = None
if mounting_change == 1: # Is mounted, so should revert to unmounted
outcome = model.delete_tenta_mounting(module_code,
target_ay_sem)
elif mounting_change == 0: # Is unmounted, so should revert to mounted
current_ay_sem = input_data.currentAySem
quota = model.get_quota_of_target_fixed_ay_sem(
module_code, current_ay_sem)
outcome = model.add_tenta_mounting(module_code, target_ay_sem,
quota)
if not test_data:
return Outcome().POST("restore_module", outcome, module_code)
elif restore_type.lower() == "moduledetails":
original_module_details = model.get_original_module_info(
module_code)
model.remove_original_module_info(module_code)
outcome = model.update_module(module_code,
original_module_details[1],
original_module_details[2],
original_module_details[3])
if not test_data:
return Outcome().POST("restore_module", outcome, module_code)
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 POST(self):
'''
Handles the deletion of a module
'''
# Verify that module exists
input_data = model.validate_input(web.input(), ["code"],
show_404=False)
try:
module_code = input_data.code
except AttributeError:
return Outcome().POST("delete_module", False, None)
# Verify that module's status is 'New'
module_infos = model.get_new_modules()
new_modules = [module_info[0] for module_info in module_infos]
if module_code not in new_modules:
return Outcome().POST("delete_module", False, None)
else:
outcome = model.delete_module(module_code)
if outcome is False:
tenta_mounted_modules = model.get_all_tenta_mounted_modules()
tenta_mounted_module_codes = [
module[0] for module in tenta_mounted_modules
]
if module_code in tenta_mounted_module_codes:
return Outcome().POST("delete_module", "has_mounting",
module_code)
else:
return Outcome().POST("delete_module", "is_starred",
module_code)
else:
return Outcome().POST("delete_module", True, module_code)
def POST(self):
'''
called from search with ay sem form
'''
#will have input data as function is called from button
input_data = model.validate_input(web.input(), ["aysem"])
ay_sem = input_data.aysem
raise web.seeother('/nonOverlappingModules?aysem=' + ay_sem)
def POST(self):
'''
Handles the submission of the 'Edit Specific Module Info' page
'''
input_data = model.validate_input(web.input(), ["code", "aysem"],
is_future=True, show_404=False)
module_code = None
ay_sem = None
try:
module_code = input_data.code
ay_sem = input_data.aysem
mounting_status = input_data.mountingStatus
except AttributeError:
return Outcome().POST("edit_mounting", False, module_code, ay_sem)
try:
quota = input_data.quota
if quota == "":
quota = None
except AttributeError:
quota = None
outcome = None
# If quota is being set by the user, it should not fall below 0.
# Otherwise, if the user is not interested in leaving a value for
# the quota, leaving it blank (none) is acceptable.
if quota is not None:
try:
quota = int(quota)
if quota < 0 or quota > 999:
outcome = False
except ValueError: # quota is not None or int
outcome = False
if outcome is not False:
module_info = model.get_module(module_code)
if module_info is None:
outcome = False
elif ay_sem not in self.list_of_future_ay_sems:
outcome = False
else:
if mounting_status == "Mounted":
outcome = None
old_mounting_status = model.get_mounting_of_target_tenta_ay_sem(module_code,
ay_sem)
if old_mounting_status is True:
outcome = model.update_quota(module_code, ay_sem, quota)
else:
outcome = model.add_tenta_mounting(module_code, ay_sem, quota)
elif mounting_status == "Not Mounted":
outcome = model.delete_tenta_mounting(module_code, ay_sem)
else:
outcome = False
return Outcome().POST("edit_mounting", outcome, module_code, ay_sem)
def POST(self):
'''
Invoked when user wants to search for modules
before internship with a specified AY-Sem
'''
# will have input data as function is called from button
input_data = model.validate_input(web.input(), ["aysem"])
ay_sem = input_data.aysem
raise web.seeother('/moduleTakenPriorToInternship?aysem=' + ay_sem)
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 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):
'''
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):
'''
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 POST(self):
'''
Handles the submission of updated module prerequisites
for a target module.
'''
isSucessfullyUpdated = False
input_data = model.validate_input(web.input(), ["code"], show_404=False)
if input_data:
module_code = input_data.code.upper()
prerequisites = json.loads(input_data.prerequisites)
isSucessfullyUpdated = model.edit_prerequisite(module_code, prerequisites)
new_prerequisites = model.get_prerequisite_as_string(module_code)
response = [isSucessfullyUpdated, new_prerequisites]
return json.dumps(response)
def POST(self, *test_data):
'''
Handles the submission of the 'Edit General Module Info' page
'''
if test_data: # for testing purposes
input_data = test_data[0]
else:
input_data = model.validate_input(web.input(), ["code"], show_404=False)
module_code = None
try:
module_code = input_data.code
module_name = input_data.name
module_desc = input_data.desc
module_mc = input_data.mc
#validate inputs
if not model.check_name(module_name):
return model.outcome_invalid()
except AttributeError:
return Outcome().POST("edit_module", False, module_code)
# Validate that MC is a number and is between 0 and 12
if not model.check_mcs(module_mc):
return Outcome().POST("edit_module", False, module_code)
old_module_info = model.get_module(module_code)
old_module_name = old_module_info[1]
old_module_desc = old_module_info[2]
old_module_mc = old_module_info[3]
outcome = True
module_info = model.get_module(module_code)
if module_info is None:
outcome = False
elif (module_name != old_module_name or module_desc != old_module_desc or
int(module_mc) != int(old_module_mc)):
model.store_original_module_info(module_code, old_module_name,
old_module_desc, old_module_mc)
outcome = model.update_module(module_code, module_name, module_desc, module_mc)
if not test_data:
return Outcome().POST("edit_module", outcome, module_code)
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):
'''
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):
'''
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):
'''
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):
'''
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, *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):
'''
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)
