def test_affiliation_data(self):
pws = PWS()
person1 = pws.get_person_by_netid("javerage")
self.assertEquals(person1.is_student, True)
self.assertEquals(person1.is_alum, True)
self.assertEquals(person1.is_staff, True)
self.assertEquals(person1.is_faculty, None)
self.assertEquals(person1.is_employee, True)
self.assertEquals(person1.mailstop, None, "MailStop")
self.assertEquals(person1.home_department, "C&C TEST BUDGET",
"HomeDepartment")
self.assertEquals(person1.student_number, "1033334")
self.assertEquals(person1.employee_id, "123456789")
self.assertEquals(person1.student_department1, "Informatics")
self.assertEquals(person1.student_department2, None)
self.assertEquals(person1.student_department3, None)
person2 = pws.get_person_by_netid("finals1")
self.assertEquals(person2.is_student, True)
self.assertEquals(person2.is_alum, True)
self.assertEquals(person2.is_staff, True)
self.assertEquals(person2.is_faculty, None)
self.assertEquals(person2.is_employee, True)
self.assertEquals(person2.home_department, "C&C TEST BUDGET",
"HomeDepartment")
self.assertEquals(person2.student_number, "1033334")
self.assertEquals(person2.employee_id, "123456789")
self.assertEquals(person2.student_class, None)
self.assertEquals(person2.student_department1, None)
self.assertEquals(person2.student_department2, None)
self.assertEquals(person2.student_department3, None)
def test_delay(self):
with self.settings(
RESTCLIENTS_PWS_DAO_CLASS='restclients.dao_implementation.pws.File',
RESTCLIENTS_MOCKDATA_DELAY=0.1):
t0 = time.time()
pws = PWS()
person = pws.get_person_by_employee_id('123456789')
t1 = time.time()
delta = t1-t0
# There are 2 requests, so it should be 2x the delay.
# Giving .01 seconds for the rest of the work. should be plenty,
# it was taking 0.2022 seconds in my test runs.
self.assertGreater(delta, 0.2)
self.assertLess(delta, 0.22)
with self.settings(
RESTCLIENTS_PWS_DAO_CLASS='restclients.dao_implementation.pws.File',
RESTCLIENTS_MOCKDATA_DELAY=0.2):
t0 = time.time()
pws = PWS()
person = pws.get_person_by_employee_id('123456789')
t1 = time.time()
delta = t1-t0
self.assertGreater(delta, 0.4)
self.assertLess(delta, 0.42)
def test_missing_person_affiliations(self):
with self.settings(
RESTCLIENTS_PWS_DAO_CLASS='restclients.dao_implementation.pws.File'):
pws = PWS()
person = pws.get_person_by_netid("bill")
self.assertEquals(person.employee_id, u'')
self.assertEquals(person.student_number, u'')
self.assertEquals(person.student_class, u'')
def _test_netid(self, netid, regid):
with self.settings(
RESTCLIENTS_PWS_DAO_CLASS='restclients.dao_implementation.pws.File'):
pws = PWS()
entity = pws.get_entity_by_netid(netid)
self.assertEquals(entity.uwnetid, netid, netid + "'s netid")
self.assertEquals(entity.uwregid, regid, netid + "'s regid")
def _test_regid(self, netid, regid):
with self.settings(
RESTCLIENTS_PWS_DAO_CLASS='restclients.dao_implementation.pws.File'):
pws = PWS()
person = pws.get_person_by_regid(regid)
self.assertEquals(person.uwnetid, netid, netid + "'s netid")
self.assertEquals(person.uwregid, regid, netid + "'s regid")
def test_compare_persons(self):
pws = PWS()
person1 = pws.get_person_by_regid("7718EB38AE3411D689DA0004AC494FFE")
person2 = pws.get_person_by_regid("7718EB38AE3411D689DA0004AC494FFE")
person3 = pws.get_person_by_regid("9136CCB8F66711D5BE060004AC494FFE")
self.assertEquals(person1 == person2, True, "persons are equal")
self.assertEquals(person1 == person3, False, "persons are inequal")
def test_names(self):
pws = PWS()
person = pws.get_person_by_netid('javerage')
self.assertEquals(person.surname, 'STUDENT')
self.assertEquals(person.first_name, 'JAMES AVERAGE')
self.assertEquals(person.full_name, 'JAMES AVERAGE STUDENT')
self.assertEquals(person.display_name, 'James Student')
self.assertEquals(person.student_number, "1033334")
self.assertEquals(person.employee_id, "123456789")
self.assertEquals(person.student_class, "Junior")
def test_compare_persons(self):
with self.settings(
RESTCLIENTS_PWS_DAO_CLASS='restclients.dao_implementation.pws.File'):
pws = PWS()
person1 = pws.get_person_by_regid("7718EB38AE3411D689DA0004AC494FFE")
person2 = pws.get_person_by_regid("7718EB38AE3411D689DA0004AC494FFE")
person3 = pws.get_person_by_regid("9136CCB8F66711D5BE060004AC494FFE")
self.assertEquals(person1 == person2, True, "persons are equal")
self.assertEquals(person1 == person3, False, "persons are inequal")
def test_pws_regid_500(self):
with self.settings(RESTCLIENTS_PWS_DAO_CLASS='restclients.dao_implementation.errors.Always500'):
pws = PWS()
self.assertRaises(DataFailureException, pws.get_person_by_regid, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")
try:
pws.get_person_by_regid("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")
self.fail("This needs to be an exception")
except DataFailureException as ex:
self.assertEqual(ex.status, 500, "Exception has the right status")
self.assertEqual(ex.url, "/identity/v1/person/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/full.json", "Exception has the right url")
def test_names(self):
with self.settings(
RESTCLIENTS_PWS_DAO_CLASS='restclients.dao_implementation.pws.File'):
pws = PWS()
person = pws.get_person_by_netid('javerage')
self.assertEquals(person.surname, 'STUDENT')
self.assertEquals(person.first_name, 'JAMES AVERAGE')
self.assertEquals(person.full_name, 'JAMES AVERAGE STUDENT')
self.assertEquals(person.display_name, 'James Student')
self.assertEquals(person.student_number, "1033334")
self.assertEquals(person.employee_id, "123456789")
self.assertEquals(person.student_class, "Junior")
def json_for_evaluation(request, evaluations, section_summer_term):
if evaluations is None:
return None
local_tz = timezone.get_current_timezone()
today = get_comparison_date(request)
now = local_tz.localize(
datetime(today.year, today.month, today.day, 0, 0, 1))
# the start date of the default show window
show_date = get_bof_7d_before_last_instruction(request)
on_dt = local_tz.localize(
datetime(show_date.year, show_date.month, show_date.day, 0, 0, 0))
# the end date of the default show window
hide_date = get_eof_term(request, True)
off_dt = local_tz.localize(
datetime(hide_date.year, hide_date.month, hide_date.day, 0, 0, 0))
if now < on_dt or now > off_dt:
return None
pws = PWS()
json_data = []
for evaluation in evaluations:
if term_matched(request, section_summer_term):
if now < evaluation.eval_open_date or\
now >= evaluation.eval_close_date:
continue
if evaluation.eval_close_date < off_dt:
off_dt = evaluation.eval_close_date
json_item = {'instructors': [],
'url': evaluation.eval_url,
'is_multi_instr': len(evaluation.instructor_ids) > 1}
for eid in evaluation.instructor_ids:
instructor_json = {}
instructor = pws.get_person_by_employee_id(eid)
instructor_json['instructor_name'] = instructor.display_name
instructor_json['instructor_title'] = instructor.title1
json_item['instructors'].append(instructor_json)
json_data.append(json_item)
# althrough each item has its own close date, we
# only take one - the earliest.
if len(json_data) > 0:
return {'evals': json_data,
'close_date': off_dt.isoformat()}
return None
def get_person_by_regid(regid):
pws = PWS()
try:
person = pws.get_person_by_regid(regid)
valid_net_id(person.uwnetid)
except DataFailureException as err:
if err.status == 404: # Non-personal regid?
person = pws.get_entity_by_regid(regid)
valid_nonpersonal_net_id(person.netid)
else:
raise
return person
def get_person_by_netid(netid):
pws = PWS()
try:
valid_net_id(netid)
person = pws.get_person_by_netid(netid)
except DataFailureException as err:
if err.status == 404: # Non-personal netid?
valid_nonpersonal_net_id(netid)
person = pws.get_entity_by_netid(netid)
else:
raise
return person
def test_by_rfid(self):
pws = PWS()
person = pws.get_person_by_prox_rfid('1223221621633408')
self.assertEquals(person.uwnetid, 'javerage', "Correct netid")
self.assertEquals(person.uwregid,
'9136CCB8F66711D5BE060004AC494FFE', "Correct regid")
# Valid non-existent RFID
self.assertRaises(DataFailureException,
pws.get_person_by_prox_rfid,
'1234567890123456')
self.assertRaises(InvalidProxRFID,
pws.get_person_by_prox_rfid,
'123456')
def test_by_student_number(self):
pws = PWS()
person = pws.get_person_by_student_number('1234567')
self.assertEquals(person.uwnetid, 'javerage', "Correct netid")
self.assertEquals(person.uwregid,
'9136CCB8F66711D5BE060004AC494FFE', "Correct regid")
# Valid non-existent student number
self.assertRaises(DataFailureException,
pws.get_person_by_student_number,
'9999999')
self.assertRaises(InvalidStudentNumber,
pws.get_person_by_student_number,
'123456')
def test_pws_netid_500(self):
with self.settings(RESTCLIENTS_PWS_DAO_CLASS=
'restclients.dao_implementation.errors.Always500'):
pws = PWS()
self.assertRaises(DataFailureException, pws.get_person_by_netid,
"fake")
try:
pws.get_person_by_netid("fake")
self.fail("This needs to be an exception")
except DataFailureException as ex:
self.assertEqual(ex.status, 500,
"Exception has the right status")
self.assertEqual(ex.url, "/identity/v1/person/fake/full.json",
"Exception has the right url")
def test_by_student_number(self):
with self.settings(
RESTCLIENTS_PWS_DAO_CLASS='restclients.dao_implementation.pws.File'):
pws = PWS()
person = pws.get_person_by_student_number('1234567')
self.assertEquals(person.uwnetid, 'javerage', "Correct netid")
self.assertEquals(person.uwregid, '9136CCB8F66711D5BE060004AC494FFE', "Correct regid")
# Valid non-existent student number
self.assertRaises(DataFailureException,
pws.get_person_by_student_number,
'9999999')
self.assertRaises(InvalidStudentNumber,
pws.get_person_by_student_number,
'123456')
def test_by_employeeid(self):
pws = PWS()
person = pws.get_person_by_employee_id('123456789')
self.assertEquals(person.uwnetid, 'javerage', "Correct netid")
self.assertEquals(
person.uwregid,
'9136CCB8F66711D5BE060004AC494FFE', "Correct regid")
self.assertRaises(InvalidEmployeeID,
pws.get_person_by_employee_id,
'12345')
# Valid non-existent employee ID
self.assertRaises(DataFailureException,
pws.get_person_by_employee_id,
'999999999')
def json_for_evaluation(request, evaluations, section):
"""
@return the json format of only the evaluations that
should be shown; [] if none should be displaued at the moment;
or None if error in fetching data.
This function should not be called if not in
in_coursevel_fetch_window.
"""
if evaluations is None:
return None
# to compare with timezone aware datetime object
now = _get_local_tz().localize(get_comparison_datetime(request))
pws = PWS()
json_data = []
for evaluation in evaluations:
if summer_term_overlaped(request, section):
logger.debug(
"Is %s within eval open close dates (%s, %s)==>%s" % (
now, evaluation.eval_open_date,
evaluation.eval_close_date,
(now >= evaluation.eval_open_date and
now < evaluation.eval_close_date)))
if evaluation.is_completed or\
now < evaluation.eval_open_date or\
now >= evaluation.eval_close_date:
continue
json_item = {
'instructors': [],
'url': evaluation.eval_url,
'close_date': datetime_str(evaluation.eval_close_date),
'is_multi_instr': len(evaluation.instructor_ids) > 1
}
for eid in evaluation.instructor_ids:
instructor_json = {}
instructor = pws.get_person_by_employee_id(eid)
instructor_json['instructor_name'] = instructor.display_name
instructor_json['instructor_title'] = instructor.title1
json_item['instructors'].append(instructor_json)
json_data.append(json_item)
return json_data
def json_for_evaluation(request, evaluations, section):
"""
@return the json format of only the evaluations that
should be shown; [] if none should be displaued at the moment;
or None if error in fetching data.
This function should not be called if not in
in_coursevel_fetch_window.
"""
if evaluations is None:
return None
# to compare with timezone aware datetime object
now = _get_local_tz().localize(get_comparison_datetime(request))
pws = PWS()
json_data = []
for evaluation in evaluations:
if summer_term_overlaped(request, section):
logger.debug(
"Is %s within eval open close dates (%s, %s)==>%s" %
(now, evaluation.eval_open_date, evaluation.eval_close_date,
(now >= evaluation.eval_open_date
and now < evaluation.eval_close_date)))
if evaluation.is_completed or\
now < evaluation.eval_open_date or\
now >= evaluation.eval_close_date:
continue
json_item = {
'instructors': [],
'url': evaluation.eval_url,
'close_date': datetime_str(evaluation.eval_close_date),
'is_multi_instr': len(evaluation.instructor_ids) > 1
}
for eid in evaluation.instructor_ids:
instructor_json = {}
instructor = pws.get_person_by_employee_id(eid)
instructor_json['instructor_name'] = instructor.display_name
instructor_json['instructor_title'] = instructor.title1
json_item['instructors'].append(instructor_json)
json_data.append(json_item)
return json_data
def test_user_fullname(self):
with self.settings(
LOGIN_DOMAIN_WHITELIST=['gmail.com'],
RESTCLIENTS_PWS_DAO_CLASS='restclients.dao_implementation.pws.File'):
user = PWS().get_person_by_netid('javerage')
user.display_name = None
self.assertEquals(user_fullname(user), 'James Student')
user.display_name = ''
self.assertEquals(user_fullname(user), 'James Student')
user.display_name = 'JOHN SMITH'
self.assertEquals(user_fullname(user), 'James Student')
user.display_name = 'Johnny S'
self.assertEquals(user_fullname(user), user.display_name)
# non-personal netid
user = PWS().get_entity_by_netid('somalt')
self.assertEquals(user_fullname(user), user.display_name)
user = get_person_by_gmail_id('*****@*****.**')
self.assertEquals(user_fullname(user), 'john.smith')
user = InvalidPerson()
self.assertRaises(UserPolicyException, user_fullname, user)
def person_from_username(username):
try:
return PWS().get_person_by_netid(username.lower())
except InvalidNetID as ex:
raise InvalidUser()
except DataFailureException as ex:
if ex.status == 404:
raise InvalidUser()
else:
raise
def test_bad_employee_ids(self):
with self.settings(
RESTCLIENTS_PWS_DAO_CLASS='restclients.dao_implementation.pws.File'):
pws = PWS()
self.assertRaises(InvalidEmployeeID, pws.get_person_by_employee_id, "")
self.assertRaises(InvalidEmployeeID, pws.get_person_by_employee_id, " ")
self.assertRaises(InvalidEmployeeID, pws.get_person_by_employee_id, "A")
self.assertRaises(InvalidEmployeeID, pws.get_person_by_employee_id, "12345678N")
self.assertRaises(InvalidEmployeeID, pws.get_person_by_employee_id, "1")
self.assertRaises(InvalidEmployeeID, pws.get_person_by_employee_id, "1234567890")
def test_bad_netids(self):
with self.settings(
RESTCLIENTS_PWS_DAO_CLASS='restclients.dao_implementation.pws.File'):
#Invalid data, should throw exceptions
pws = PWS()
self.assertRaises(InvalidNetID, pws.get_entity_by_netid, "")
self.assertRaises(InvalidNetID, pws.get_entity_by_netid, " ")
self.assertRaises(InvalidNetID, pws.get_entity_by_netid, "one two")
self.assertRaises(InvalidNetID, pws.get_entity_by_netid, "</html>")
self.assertRaises(InvalidNetID, pws.get_entity_by_netid, "aaaaaaaaa")
self.assertRaises(DataFailureException, pws.get_entity_by_netid, "hello")
def _get_person_of_current_user():
"""
Retrieve the person data using the netid of the current user
"""
timer = Timer()
try:
return PWS().get_person_by_netid(get_netid_of_current_user())
finally:
log_resp_time(logger,
'pws.get_person_by_netid',
timer)
def test_user_email(self):
with self.settings(
LOGIN_DOMAIN_WHITELIST=['gmail.com'],
RESTCLIENTS_PWS_DAO_CLASS='restclients.dao_implementation.pws.File'):
user = PWS().get_person_by_netid('javerage')
self.assertEquals(user_email(user), '*****@*****.**')
# non-personal netid
user = PWS().get_entity_by_netid('somalt')
self.assertEquals(user_email(user), '*****@*****.**')
user = get_person_by_gmail_id('*****@*****.**')
self.assertEquals(user_email(user), '*****@*****.**')
user = PWS().get_entity_by_netid('somalt')
user.uwnetid = None
self.assertRaises(UserPolicyException, user_email, user)
user = InvalidPerson()
self.assertRaises(UserPolicyException, user_email, user)
def test_actas(self):
with self.settings(
RESTCLIENTS_PWS_DAO_CLASS='restclients.dao_implementation.pws.File'):
user = Person(uwnetid="bill")
person = Person(uwregid="9136CCB8F66711D5BE060004AC494FFE")
pws = PWS()
self.assertEquals(pws.actas, None, "Correct actas attribute")
pws = PWS(actas=user.uwnetid)
self.assertEquals(pws.actas, user.uwnetid, "Correct actas attribute")
pws = PWS(actas="")
self.assertEquals(pws.actas, "", "Empty str actas attribute")
self.assertRaises(InvalidNetID, pws.get_idcard_photo, person.uwregid)
pws = PWS(actas="000")
self.assertEquals(pws.actas, "000", "Invalid actas attribute")
self.assertRaises(InvalidNetID, pws.get_idcard_photo, person.uwregid)
pws = PWS(actas=67)
self.assertEquals(pws.actas, 67, "Invalid actas attribute")
self.assertRaises(InvalidNetID, pws.get_idcard_photo, person.uwregid)
def test_affiliation_data(self):
with self.settings(
RESTCLIENTS_PWS_DAO_CLASS='restclients.dao_implementation.pws.File'):
pws = PWS()
person1 = pws.get_person_by_netid("javerage")
self.assertEquals(person1.is_student, True)
self.assertEquals(person1.is_alum, True)
self.assertEquals(person1.is_staff, True)
self.assertEquals(person1.is_faculty, None)
self.assertEquals(person1.is_employee, True)
self.assertEquals(person1.mailstop, None, "MailStop")
self.assertEquals(person1.home_department, "C&C TEST BUDGET",
"HomeDepartment")
self.assertEquals(person1.student_number, "1033334")
self.assertEquals(person1.employee_id, "123456789")
self.assertEquals(person1.student_department1, "Informatics")
self.assertEquals(person1.student_department2, None)
self.assertEquals(person1.student_department3, None)
person2 = pws.get_person_by_netid("finals1")
self.assertEquals(person2.is_student, True)
self.assertEquals(person2.is_alum, True)
self.assertEquals(person2.is_staff, True)
self.assertEquals(person2.is_faculty, None)
self.assertEquals(person2.is_employee, True)
self.assertEquals(person2.home_department, "C&C TEST BUDGET",
"HomeDepartment")
self.assertEquals(person2.student_number, "1033334")
self.assertEquals(person2.employee_id, "123456789")
self.assertEquals(person2.student_class, None)
self.assertEquals(person2.student_department1, None)
self.assertEquals(person2.student_department2, None)
self.assertEquals(person2.student_department3, None)
def _json_to_grades(data, regid, term):
grades = StudentGrades()
grades.term = term
grades.user = PWS().get_person_by_regid(regid)
grades.grade_points = data["QtrGradePoints"]
grades.credits_attempted = data["QtrGradedAttmp"]
grades.non_grade_credits = data["QtrNonGrdEarned"]
grades.grades = []
for registration in data["Registrations"]:
grade = StudentCourseGrade()
grade.grade = registration["Grade"]
grade.credits = registration["Credits"].replace(" ", "")
grade.section = get_section_by_url(registration["Section"]["Href"])
grades.grades.append(grade)
return grades
def test_bad_regids(self):
with self.settings(
RESTCLIENTS_PWS_DAO_CLASS='restclients.dao_implementation.pws.File'):
#Invalid data, should throw exceptions
pws = PWS()
self.assertRaises(InvalidRegID, pws.get_entity_by_regid, "")
self.assertRaises(InvalidRegID, pws.get_entity_by_regid, " ")
self.assertRaises(InvalidRegID, pws.get_entity_by_regid, "AAA")
self.assertRaises(InvalidRegID,
pws.get_entity_by_regid,
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")
self.assertRaises(InvalidRegID,
pws.get_entity_by_regid,
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG")
self.assertNotEquals(None,
pws.get_entity_by_regid,
"605764A811A847E690F107D763A4B32A")
def test_bad_regids(self):
with self.settings(
RESTCLIENTS_PWS_DAO_CLASS='restclients.dao_implementation.pws.File'):
#Invalid data, should throw exceptions
pws = PWS()
self.assertRaises(InvalidRegID, pws.get_person_by_regid, "")
self.assertRaises(InvalidRegID, pws.get_person_by_regid, " ")
self.assertRaises(InvalidRegID, pws.get_person_by_regid, "AAA")
self.assertRaises(InvalidRegID,
pws.get_person_by_regid,
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")
self.assertRaises(InvalidRegID,
pws.get_person_by_regid,
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG")
self.assertRaises(DataFailureException,
pws.get_person_by_regid,
"9136CCB8F66711D5BE060004AC494FFF")
def test_photo_size(self):
with self.settings(
RESTCLIENTS_PWS_DAO_CLASS='restclients.dao_implementation.pws.File'):
person = Person(uwregid="9136CCB8F66711D5BE060004AC494FFE")
pws = PWS()
img = pws.get_idcard_photo(person.uwregid)
self.assertEquals(img.len, 4661, "Correct file for default size")
img = pws.get_idcard_photo(person.uwregid, size="medium")
self.assertEquals(img.len, 4661, "Correct file for medium size")
img = pws.get_idcard_photo(person.uwregid, size="small")
self.assertEquals(img.len, 4661, "Correct file for small size")
img = pws.get_idcard_photo(person.uwregid, size="large")
self.assertEquals(img.len, 4661, "Correct file for large size")
img = pws.get_idcard_photo(person.uwregid, size=100)
self.assertEquals(img.len, 4661, "Correct file for custom size")
# Invalid size param, should throw exceptions
self.assertRaises(InvalidIdCardPhotoSize, pws.get_idcard_photo,
person.uwregid, "tiny")
self.assertRaises(InvalidIdCardPhotoSize, pws.get_idcard_photo,
person.uwregid, "larger")
self.assertRaises(InvalidIdCardPhotoSize, pws.get_idcard_photo,
person.uwregid, "60000")
self.assertRaises(InvalidIdCardPhotoSize, pws.get_idcard_photo,
person.uwregid, 60000)
self.assertRaises(InvalidIdCardPhotoSize, pws.get_idcard_photo,
person.uwregid, 0)
self.assertRaises(InvalidIdCardPhotoSize, pws.get_idcard_photo,
person.uwregid, 01)
self.assertRaises(InvalidIdCardPhotoSize, pws.get_idcard_photo,
person.uwregid, -50)
self.assertRaises(InvalidIdCardPhotoSize, pws.get_idcard_photo,
person.uwregid, 20.5)
def get_degree_by_regid(regid):
"""
raise: InvalidRegID, DataFailureException
"""
person = PWS().get_person_by_regid(regid)
return get_degree_by_syskey(person.student_system_key)
def handle(self, *args, **options):
if len(args) == 2:
subaccount_id = args[0]
sis_term_id = args[1]
else:
raise CommandError("find_active_instructors <subaccount_id> <term_id>")
accounts = Accounts()
reports = Reports()
pws = PWS()
account = accounts.get_account(subaccount_id)
term = reports.get_term_by_sis_id(sis_term_id)
enrollment_report = reports.create_enrollments_provisioning_report(account.account_id, term.term_id)
enrollment_data = reports.get_report_data(enrollment_report)
all_instructors = {}
enrollment_csv_data = csv.reader(enrollment_data)
header = enrollment_csv_data.next()
course_id_idx = header.index("course_id")
sis_user_id_idx = header.index("user_id")
role_idx = header.index("role")
status_idx = header.index("status")
for row in enrollment_csv_data:
if not len(row):
continue
course_id = row[course_id_idx]
sis_user_id = row[sis_user_id_idx]
role = row[role_idx]
status = row[status_idx]
if sis_user_id != "" and role.lower() == "teacher" and status.lower() == "active":
if course_id not in all_instructors:
all_instructors[course_id] = []
all_instructors[course_id].append(sis_user_id)
course_report = reports.create_course_provisioning_report(account.account_id, term.term_id)
course_data = reports.get_report_data(course_report)
course_csv_data = csv.reader(course_data)
header = course_csv_data.next()
course_id_idx = header.index("course_id")
sis_account_id_idx = header.index("account_id")
status_idx = header.index("status")
active_instructors = {}
for row in course_csv_data:
if not len(row):
continue
course_id = row[course_id_idx]
sis_account_id = row[sis_account_id_idx]
status = row[status_idx]
if sis_account_id != "" and status.lower() == "active" and course_id in all_instructors:
for sis_user_id in all_instructors[course_id]:
if sis_user_id not in active_instructors:
try:
person = pws.get_person_by_regid(sis_user_id)
email = person.uwnetid + "@uw.edu"
active_instructors[sis_user_id] = email
except InvalidRegID:
continue
except DataFailureException as err:
if err.status == 404:
continue
else:
raise
filename = "-".join(["active-instructors", subaccount_id, sis_term_id])
outpath = dirname(__file__) + "/" + filename + ".txt"
f = open(outpath, "w")
data = active_instructors.values()
data.sort()
f.write("\n".join(data))
f.close()
reports.delete_report(enrollment_report)
reports.delete_report(course_report)
print outpath
def graderoster_from_xhtml(data, section, instructor):
pws = PWS()
people = {instructor.uwregid: instructor}
graderoster = GradeRoster()
graderoster.section = section
graderoster.instructor = instructor
graderoster.authorized_grade_submitters = []
graderoster.grade_submission_delegates = []
graderoster.items = []
tree = etree.fromstring(data.strip())
nsmap = {"xhtml": "http://www.w3.org/1999/xhtml"}
root = tree.xpath(".//xhtml:div[@class='graderoster']",
namespaces=nsmap)[0]
default_section_id = None
el = root.xpath("./xhtml:div/xhtml:a[@rel='section']/*[@class='section_id']",
namespaces=nsmap)[0]
default_section_id = el.text.upper()
el = root.xpath("./xhtml:div/*[@class='section_credits']",
namespaces=nsmap)[0]
if el.text is not None:
graderoster.section_credits = el.text.strip()
el = root.xpath("./xhtml:div/*[@class='writing_credit_display']",
namespaces=nsmap)[0]
if el.get("checked", "") == "checked":
graderoster.allows_writing_credit = True
for el in root.xpath("./xhtml:div//*[@rel='authorized_grade_submitter']",
namespaces=nsmap):
reg_id = el.xpath(".//*[@class='reg_id']")[0].text.strip()
if reg_id not in people:
people[reg_id] = pws.get_person_by_regid(reg_id)
graderoster.authorized_grade_submitters.append(people[reg_id])
for el in root.xpath("./xhtml:div//*[@class='grade_submission_delegate']",
namespaces=nsmap):
reg_id = el.xpath(".//*[@class='reg_id']")[0].text.strip()
delegate_level = el.xpath(".//*[@class='delegate_level']")[0].text.strip()
if reg_id not in people:
people[reg_id] = pws.get_person_by_regid(reg_id)
delegate = GradeSubmissionDelegate(person=people[reg_id],
delegate_level=delegate_level)
graderoster.grade_submission_delegates.append(delegate)
for item in root.xpath("./*[@class='graderoster_items']/*[@class='graderoster_item']"):
gr_item = GradeRosterItem(section_id=default_section_id)
gr_item.grade_choices = []
for el in item.xpath(".//xhtml:a[@rel='student']/*[@class='reg_id']",
namespaces=nsmap):
gr_item.student_uwregid = el.text.strip()
for el in item.xpath(".//xhtml:a[@rel='student']/*[@class='name']",
namespaces=nsmap):
full_name = el.text.strip()
try:
(surname, first_name) = full_name.split(",", 1)
gr_item.student_first_name = first_name
gr_item.student_surname = surname
except ValueError:
pass
for el in item.xpath(".//*[@class]"):
classname = el.get("class")
if classname == "duplicate_code" and el.text is not None:
duplicate_code = el.text.strip()
if len(duplicate_code):
gr_item.duplicate_code = duplicate_code
elif classname == "section_id" and el.text is not None:
gr_item.section_id = el.text.strip()
elif classname == "student_former_name" and el.text is not None:
student_former_name = el.text.strip()
if len(student_former_name):
gr_item.student_former_name = student_former_name
elif classname == "student_number":
gr_item.student_number = el.text.strip()
elif classname == "student_credits" and el.text is not None:
gr_item.student_credits = el.text.strip()
elif "date_withdrawn" in classname and el.text is not None:
gr_item.date_withdrawn = el.text.strip()
elif classname == "incomplete":
if el.get("checked", "") == "checked":
gr_item.has_incomplete = True
if el.get("disabled", "") != "disabled":
gr_item.allows_incomplete = True
elif classname == "writing_course":
if el.get("checked", "") == "checked":
gr_item.has_writing_credit = True
elif classname == "auditor":
if el.get("checked", "") == "checked":
gr_item.is_auditor = True
elif classname == "no_grade_now":
if el.get("checked", "") == "checked":
gr_item.no_grade_now = True
elif classname == "grades":
if el.get("disabled", "") != "disabled":
gr_item.allows_grade_change = True
elif classname == "grade":
grade = el.text.strip() if el.text is not None else ""
gr_item.grade_choices.append(grade)
if el.get("selected", "") == "selected":
gr_item.grade = grade
elif classname == "grade_document_id" and el.text is not None:
gr_item.grade_document_id = el.text.strip()
elif "date_graded" in classname and el.text is not None:
gr_item.date_graded = el.text.strip()
elif classname == "grade_submitter_source" and el.text is not None:
gr_item.grade_submitter_source = el.text.strip()
elif classname == "code" and el.text is not None:
gr_item.status_code = el.text.strip()
elif classname == "message" and el.text is not None:
gr_item.status_message = el.text.strip()
for el in item.xpath(".//xhtml:a[@rel='grade_submitter_person']/*[@class='reg_id']",
namespaces=nsmap):
reg_id = el.text.strip()
if reg_id not in people:
people[reg_id] = pws.get_person_by_regid(reg_id)
gr_item.grade_submitter_person = people[reg_id]
graderoster.items.append(gr_item)
return graderoster
def _test_netid(self, netid, regid):
pws = PWS()
person = pws.get_person_by_netid(netid)
self.assertEquals(person.uwnetid, netid, netid + "'s netid")
self.assertEquals(person.uwregid, regid, netid + "'s regid")
def get_registrations_changed_since(self, term, since_dt):
url = '/uweomyuw/feed/registrationWS.asp'
params = {'year': term.year, 'quarter': term.quarter.lower()}
if since_dt:
since_dt = localtime(since_dt)
params['last_modified_date'] = since_dt.strftime('%m/%d/%Y %H:%M')
xml_root = self._get_resource('%s?%s' % (url, urlencode(params)))
registrations = []
pws = PWS()
for el in xml_root.findall('row'):
registration = Registration()
student_number = el.find('student_number').text.strip()
try:
person = pws.get_person_by_student_number(student_number)
registration.person = person
except DataFailureException as ex:
self._log.info('Skipping student_number %s: %s' % (
student_number, ex))
continue
section = self._eos_section()
section.term = Term(
year=int(el.find('year').text.strip()),
quarter=el.find('quarter').text.strip().lower()
)
section.curriculum_abbr = el.find(
'curriculum_abbreviation').text.strip()
section.course_number = el.find('course_number').text.strip()
section.section_id = el.find('section_id').text.strip()
registration.section = section
is_credit = el.find('is_credit')
registration.is_credit = True if (
is_credit is not None and
is_credit.text.strip() == '1') else False
if registration.is_credit:
try:
self._update_is_primary(section)
except PrimaryEnrollmentException as err:
self._log.info('Skipping registration for %s: %s' % (
student_number, err))
continue
registration.request_status = el.find(
'request_status').text.strip().lower()
is_active = el.find('is_active')
registration.is_active = True if (
is_active is not None and
is_active.text.strip() == '1') else False
is_deleted = el.find('is_deleted')
if (is_deleted is not None and is_deleted.text.strip() == '1'):
registration.is_active = False
registrations.append(registration)
return registrations
def test_missing_person_affiliations(self):
pws = PWS()
person = pws.get_person_by_netid("bill")
self.assertEquals(person.employee_id, u'')
self.assertEquals(person.student_number, u'')
self.assertEquals(person.student_class, u'')
def test_not_in_pws_netid(self):
self.assertRaises(InvalidNetID,
PWS().get_person_by_netid, "thisisnotarealnetid")
def get_courses_changed_since(self, term, since_dt):
url = '/uweomyuw/feed/courseSectionWS.asp'
params = {'year': term.year, 'quarter': term.quarter.lower(),
'resultSetOption': 1}
if since_dt:
since_dt = localtime(since_dt)
params['last_modified_date'] = since_dt.strftime('%m/%d/%Y %H:%M')
xml_root = self._get_resource('%s?%s' % (url, urlencode(params)))
courses = {}
for el in xml_root.findall('row'):
section = self._eos_section()
section.term = term
section.eos_course_id = el.find('EOScourseId').text.strip()
section.curriculum_abbr = el.find(
'CurriculumAbbreviation').text.strip()
section.course_number = el.find('CourseNumber').text.strip()
section.section_id = el.find('SectionID').text.strip()
section.course_campus = el.find('CourseCampus').text.strip()
course_title = el.find('CourseTitle')
if course_title is not None:
section.course_title = course_title.text.strip()
course_title_long = el.find('CourseTitleLong')
if course_title_long is not None:
section.course_title_long = course_title_long.text.strip()
primary_lms = el.find('primaryLMS')
if primary_lms is not None:
section.primary_lms = primary_lms.text.strip()
lms_ownership = el.find('LMSOwnership')
section.lms_ownership = None if (
lms_ownership is None) else lms_ownership.text.strip()
section.delete_flag = el.find('DeleteFlag').text.strip()
section.is_withdrawn = True if (
'withdrawn' == section.delete_flag) else False
is_independent_start = el.find('IsIndependentStart')
section.is_independent_start = True if (
is_independent_start is not None and
is_independent_start.text.strip() == '1') else False
course_id = section.canvas_course_sis_id()
try:
override = TermOverride.objects.get(course_id=course_id)
if not section.is_independent_start:
override.delete()
except TermOverride.DoesNotExist:
if section.is_independent_start:
override = TermOverride(
course_id=course_id,
term_sis_id="uweo-individual-start",
term_name="UWEO Individual Start"
)
override.save()
is_credit = el.find('is_credit')
section.is_credit = True if (
is_credit is not None and
is_credit.text.strip() == '1') else False
courses[section.eos_course_id] = section
# Get the instructors
params['resultSetOption'] = 2
xml_root = self._get_resource('%s?%s' % (url, urlencode(params)))
pws = PWS()
for el in xml_root.findall('row'):
eos_course_id = el.find('EOScourseId').text.strip()
course = courses[eos_course_id]
employee_id = el.find('EmployeeID').text.strip()
try:
person = pws.get_person_by_employee_id(employee_id)
course.meetings[0].instructors.append(person)
except DataFailureException as ex:
self._log.info('Skipping employee_id %s: %s' % (
employee_id, ex))
continue
return courses.values()
def _test_netid(self, netid, regid):
pws = PWS()
entity = pws.get_entity_by_netid(netid)
self.assertEquals(entity.uwnetid, netid, netid + "'s netid")
self.assertEquals(entity.uwregid, regid, netid + "'s regid")
def graderoster_from_xhtml(data, section, instructor):
pws = PWS()
people = {instructor.uwregid: instructor}
graderoster = GradeRoster()
graderoster.section = section
graderoster.instructor = instructor
graderoster.authorized_grade_submitters = []
graderoster.grade_submission_delegates = []
graderoster.items = []
tree = etree.fromstring(data.strip())
nsmap = {"xhtml": "http://www.w3.org/1999/xhtml"}
root = tree.xpath(".//xhtml:div[@class='graderoster']",
namespaces=nsmap)[0]
default_section_id = None
el = root.xpath("./xhtml:div/xhtml:a[@rel='section']/*[@class='section_id']",
namespaces=nsmap)[0]
default_section_id = el.text.upper()
el = root.xpath("./xhtml:div/*[@class='section_credits']",
namespaces=nsmap)[0]
if el.text is not None:
graderoster.section_credits = el.text.strip()
el = root.xpath("./xhtml:div/*[@class='writing_credit_display']",
namespaces=nsmap)[0]
if el.get("checked", "") == "checked":
graderoster.allows_writing_credit = True
for el in root.xpath("./xhtml:div//*[@rel='authorized_grade_submitter']",
namespaces=nsmap):
reg_id = el.xpath(".//*[@class='reg_id']")[0].text.strip()
if reg_id not in people:
people[reg_id] = pws.get_person_by_regid(reg_id)
graderoster.authorized_grade_submitters.append(people[reg_id])
for el in root.xpath("./xhtml:div//*[@class='grade_submission_delegate']",
namespaces=nsmap):
reg_id = el.xpath(".//*[@class='reg_id']")[0].text.strip()
delegate_level = el.xpath(".//*[@class='delegate_level']")[0].text.strip()
if reg_id not in people:
people[reg_id] = pws.get_person_by_regid(reg_id)
delegate = GradeSubmissionDelegate(person=people[reg_id],
delegate_level=delegate_level)
graderoster.grade_submission_delegates.append(delegate)
for item in root.xpath("./*[@class='graderoster_items']/*[@class='graderoster_item']"):
gr_item = GradeRosterItem(section_id=default_section_id)
gr_item.grade_choices = []
for el in item.xpath(".//xhtml:a[@rel='student']/*[@class='reg_id']",
namespaces=nsmap):
gr_item.student_uwregid = el.text.strip()
for el in item.xpath(".//xhtml:a[@rel='student']/*[@class='name']",
namespaces=nsmap):
full_name = el.text.strip()
try:
(surname, first_name) = full_name.split(",", 1)
gr_item.student_first_name = first_name
gr_item.student_surname = surname
except ValueError:
pass
for el in item.xpath(".//*[@class]"):
classname = el.get("class")
if classname == "duplicate_code" and el.text is not None:
duplicate_code = el.text.strip()
if len(duplicate_code):
gr_item.duplicate_code = duplicate_code
elif classname == "section_id" and el.text is not None:
gr_item.section_id = el.text.strip()
elif classname == "student_former_name" and el.text is not None:
student_former_name = el.text.strip()
if len(student_former_name):
gr_item.student_former_name = student_former_name
elif classname == "student_number":
gr_item.student_number = el.text.strip()
elif classname == "student_credits" and el.text is not None:
gr_item.student_credits = el.text.strip()
elif "date_withdrawn" in classname and el.text is not None:
gr_item.date_withdrawn = el.text.strip()
elif classname == "incomplete":
if el.get("checked", "") == "checked":
gr_item.has_incomplete = True
if el.get("disabled", "") != "disabled":
gr_item.allows_incomplete = True
elif classname == "writing_course":
if el.get("checked", "") == "checked":
gr_item.has_writing_credit = True
elif classname == "auditor":
if el.get("checked", "") == "checked":
gr_item.is_auditor = True
elif classname == "no_grade_now":
if el.get("checked", "") == "checked":
gr_item.no_grade_now = True
elif classname == "grades":
if el.get("disabled", "") != "disabled":
gr_item.allows_grade_change = True
elif classname == "grade":
grade = el.text.strip() if el.text is not None else ""
gr_item.grade_choices.append(grade)
if el.get("selected", "") == "selected":
gr_item.grade = grade
elif classname == "grade_document_id" and el.text is not None:
gr_item.grade_document_id = el.text.strip()
elif "date_graded" in classname and el.text is not None:
gr_item.date_graded = el.text.strip()
elif classname == "grade_submitter_source" and el.text is not None:
gr_item.grade_submitter_source = el.text.strip()
elif classname == "code" and el.text is not None:
gr_item.status_code = el.text.strip()
elif classname == "message" and el.text is not None:
gr_item.status_message = el.text.strip()
for el in item.xpath(".//xhtml:a[@rel='grade_submitter_person']/*[@class='reg_id']",
namespaces=nsmap):
reg_id = el.text.strip()
if reg_id not in people:
people[reg_id] = pws.get_person_by_regid(reg_id)
gr_item.grade_submitter_person = people[reg_id]
graderoster.items.append(gr_item)
return graderoster
def _json_to_section(section_data,
term=None,
include_instructor_not_on_time_schedule=True):
"""
Returns a section model created from the passed json.
"""
pws = PWS()
section = Section()
if term is not None and (
term.year == int(section_data["Course"]["Year"]) and
term.quarter == section_data["Course"]["Quarter"]):
section.term = term
else:
section.term = get_term_by_year_and_quarter(
section_data["Course"]["Year"],
section_data["Course"]["Quarter"])
section.curriculum_abbr = section_data["Course"][
"CurriculumAbbreviation"]
section.course_number = section_data["Course"]["CourseNumber"]
section.course_title = section_data["CourseTitle"]
section.course_title_long = section_data["CourseTitleLong"]
section.course_campus = section_data["CourseCampus"]
section.section_id = section_data["SectionID"]
section.institute_name = section_data.get("InstituteName", "")
section.primary_lms = section_data.get("PrimaryLMS", None)
section.lms_ownership = section_data.get("LMSOwnership", None)
section.is_independent_start = section_data.get("IsIndependentStart",
False)
# Some section data sources have different formats for these dates.
try:
date_format = "%Y-%m-%d"
if section_data.get("StartDate", None):
str_date = section_data["StartDate"]
start_date = datetime.strptime(str_date, date_format).date()
section.start_date = start_date
if section_data.get("EndDate", None):
str_date = section_data["EndDate"]
section.end_date = datetime.strptime(str_date, date_format).date()
except Exception as ex:
pass
section.section_type = section_data["SectionType"]
if "independent study" == section.section_type:
section.is_independent_study = True
else:
section.is_independent_study = False
section.class_website_url = section_data["ClassWebsiteUrl"]
section.sln = section_data["SLN"]
if "SummerTerm" in section_data:
section.summer_term = section_data["SummerTerm"]
else:
section.summer_term = ""
section.delete_flag = section_data["DeleteFlag"]
if "withdrawn" == section.delete_flag:
section.is_withdrawn = True
else:
section.is_withdrawn = False
section.current_enrollment = int(section_data['CurrentEnrollment'])
section.auditors = int(section_data['Auditors'])
section.allows_secondary_grading = section_data["SecondaryGradingOption"]
primary_section = section_data["PrimarySection"]
if (primary_section is not None and
primary_section["SectionID"] != section.section_id):
section.is_primary_section = False
section.primary_section_href = primary_section["Href"]
section.primary_section_id = primary_section["SectionID"]
section.primary_section_curriculum_abbr = primary_section[
"CurriculumAbbreviation"]
section.primary_section_course_number = primary_section[
"CourseNumber"]
else:
section.is_primary_section = True
section.linked_section_urls = []
for linked_section_type in section_data["LinkedSectionTypes"]:
for linked_section_data in linked_section_type["LinkedSections"]:
url = linked_section_data["Section"]["Href"]
section.linked_section_urls.append(url)
section.joint_section_urls = []
for joint_section_data in section_data.get("JointSections", []):
url = joint_section_data["Href"]
section.joint_section_urls.append(url)
section.grade_submission_delegates = []
for del_data in section_data["GradeSubmissionDelegates"]:
delegate = GradeSubmissionDelegate(
person=pws.get_person_by_regid(del_data["Person"]["RegID"]),
delegate_level=del_data["DelegateLevel"])
section.grade_submission_delegates.append(delegate)
section.meetings = []
for meeting_data in section_data["Meetings"]:
meeting = SectionMeeting()
meeting.section = section
meeting.term = section.term
meeting.meeting_index = meeting_data["MeetingIndex"]
meeting.meeting_type = meeting_data["MeetingType"]
meeting.building = meeting_data["Building"]
if meeting_data["BuildingToBeArranged"]:
meeting.building_to_be_arranged = True
else:
meeting.building_to_be_arranged = False
meeting.room_number = meeting_data["RoomNumber"]
if meeting_data["RoomToBeArranged"]:
meeting.room_to_be_arranged = True
else:
meeting.room_to_be_arranged = False
if meeting_data["DaysOfWeekToBeArranged"]:
meeting.days_to_be_arranged = True
else:
meeting.days_to_be_arranged = False
for day_data in meeting_data["DaysOfWeek"]["Days"]:
attribute = "meets_%s" % day_data["Name"].lower()
setattr(meeting, attribute, True)
meeting.start_time = meeting_data["StartTime"]
meeting.end_time = meeting_data["EndTime"]
meeting.instructors = []
for instructor_data in meeting_data["Instructors"]:
# TSPrint: True
# Instructor information currently listed on the Time Schedule
if (instructor_data["TSPrint"] or
include_instructor_not_on_time_schedule):
pdata = instructor_data["Person"]
if "RegID" in pdata and pdata["RegID"] is not None:
try:
instructor = pws.get_person_by_regid(pdata["RegID"])
except:
instructor = Person(uwregid=pdata["RegID"],
display_name=pdata["Name"])
instructor.TSPrint = instructor_data["TSPrint"]
meeting.instructors.append(instructor)
section.meetings.append(meeting)
section.final_exam = None
if "FinalExam" in section_data and section_data["FinalExam"] is not None:
if "MeetingStatus" in section_data["FinalExam"]:
final_exam = FinalExam()
final_data = section_data["FinalExam"]
status = final_data["MeetingStatus"]
final_exam.no_exam_or_nontraditional = False
final_exam.is_confirmed = False
if (status == "2") or (status == "3"):
final_exam.is_confirmed = True
elif status == "1":
final_exam.no_exam_or_nontraditional = True
final_exam.building = final_data["Building"]
final_exam.room_number = final_data["RoomNumber"]
final_format = "%Y-%m-%d : %H:%M"
strptime = datetime.strptime
if final_data["Date"] and final_data["Date"] != "0000-00-00":
if final_data["StartTime"]:
start_string = "%s : %s" % (final_data["Date"],
final_data["StartTime"])
final_exam.start_date = strptime(start_string,
final_format)
if final_data["EndTime"]:
end_string = "%s : %s" % (final_data["Date"],
final_data["EndTime"])
final_exam.end_date = strptime(end_string, final_format)
final_exam.clean_fields()
section.final_exam = final_exam
return section
def _json_to_section(section_data,
term=None,
include_instructor_not_on_time_schedule=True):
"""
Returns a section model created from the passed json.
"""
pws = PWS()
section = Section()
if term is not None and (term.year == int(section_data["Course"]["Year"])
and term.quarter
== section_data["Course"]["Quarter"]):
section.term = term
else:
section.term = get_term_by_year_and_quarter(
section_data["Course"]["Year"], section_data["Course"]["Quarter"])
section.curriculum_abbr = section_data["Course"]["CurriculumAbbreviation"]
section.course_number = section_data["Course"]["CourseNumber"]
section.course_title = section_data["CourseTitle"]
section.course_title_long = section_data["CourseTitleLong"]
section.course_campus = section_data["CourseCampus"]
section.section_id = section_data["SectionID"]
section.institute_name = section_data.get("InstituteName", "")
section.primary_lms = section_data.get("PrimaryLMS", None)
section.lms_ownership = section_data.get("LMSOwnership", None)
section.is_independent_start = section_data.get("IsIndependentStart",
False)
section.section_type = section_data["SectionType"]
if "independent study" == section.section_type:
section.is_independent_study = True
else:
section.is_independent_study = False
section.class_website_url = section_data["ClassWebsiteUrl"]
section.sln = section_data["SLN"]
if "SummerTerm" in section_data:
section.summer_term = section_data["SummerTerm"]
else:
section.summer_term = ""
section.delete_flag = section_data["DeleteFlag"]
if "withdrawn" == section.delete_flag:
section.is_withdrawn = True
else:
section.is_withdrawn = False
section.current_enrollment = int(section_data['CurrentEnrollment'])
section.auditors = int(section_data['Auditors'])
section.allows_secondary_grading = section_data["SecondaryGradingOption"]
primary_section = section_data["PrimarySection"]
if (primary_section is not None
and primary_section["SectionID"] != section.section_id):
section.is_primary_section = False
section.primary_section_href = primary_section["Href"]
section.primary_section_id = primary_section["SectionID"]
section.primary_section_curriculum_abbr = primary_section[
"CurriculumAbbreviation"]
section.primary_section_course_number = primary_section["CourseNumber"]
else:
section.is_primary_section = True
section.linked_section_urls = []
for linked_section_type in section_data["LinkedSectionTypes"]:
for linked_section_data in linked_section_type["LinkedSections"]:
url = linked_section_data["Section"]["Href"]
section.linked_section_urls.append(url)
section.joint_section_urls = []
for joint_section_data in section_data.get("JointSections", []):
url = joint_section_data["Href"]
section.joint_section_urls.append(url)
section.grade_submission_delegates = []
for del_data in section_data["GradeSubmissionDelegates"]:
delegate = GradeSubmissionDelegate(
person=pws.get_person_by_regid(del_data["Person"]["RegID"]),
delegate_level=del_data["DelegateLevel"])
section.grade_submission_delegates.append(delegate)
section.meetings = []
for meeting_data in section_data["Meetings"]:
meeting = SectionMeeting()
meeting.section = section
meeting.term = section.term
meeting.meeting_index = meeting_data["MeetingIndex"]
meeting.meeting_type = meeting_data["MeetingType"]
meeting.building = meeting_data["Building"]
if meeting_data["BuildingToBeArranged"]:
meeting.building_to_be_arranged = True
else:
meeting.building_to_be_arranged = False
meeting.room_number = meeting_data["RoomNumber"]
if meeting_data["RoomToBeArranged"]:
meeting.room_to_be_arranged = True
else:
meeting.room_to_be_arranged = False
if meeting_data["DaysOfWeekToBeArranged"]:
meeting.days_to_be_arranged = True
else:
meeting.days_to_be_arranged = False
for day_data in meeting_data["DaysOfWeek"]["Days"]:
attribute = "meets_%s" % day_data["Name"].lower()
setattr(meeting, attribute, True)
meeting.start_time = meeting_data["StartTime"]
meeting.end_time = meeting_data["EndTime"]
meeting.instructors = []
for instructor_data in meeting_data["Instructors"]:
# TSPrint: True
# Instructor information currently listed on the Time Schedule
if instructor_data[
"TSPrint"] or include_instructor_not_on_time_schedule:
pdata = instructor_data["Person"]
if "RegID" in pdata and pdata["RegID"] is not None:
try:
instructor = pws.get_person_by_regid(pdata["RegID"])
except:
instructor = Person(uwregid=pdata["RegID"],
display_name=pdata["Name"])
instructor.TSPrint = instructor_data["TSPrint"]
meeting.instructors.append(instructor)
section.meetings.append(meeting)
section.final_exam = None
if "FinalExam" in section_data and section_data["FinalExam"] is not None:
if "MeetingStatus" in section_data["FinalExam"]:
final_exam = FinalExam()
final_data = section_data["FinalExam"]
status = final_data["MeetingStatus"]
final_exam.no_exam_or_nontraditional = False
final_exam.is_confirmed = False
if (status == "2") or (status == "3"):
final_exam.is_confirmed = True
elif status == "1":
final_exam.no_exam_or_nontraditional = True
final_exam.building = final_data["Building"]
final_exam.room_number = final_data["RoomNumber"]
final_format = "%Y-%m-%d : %H:%M"
strptime = datetime.strptime
if final_data["Date"] and final_data["Date"] != "0000-00-00":
if final_data["StartTime"]:
start_string = "%s : %s" % (final_data["Date"],
final_data["StartTime"])
final_exam.start_date = strptime(start_string,
final_format)
if final_data["EndTime"]:
end_string = "%s : %s" % (final_data["Date"],
final_data["EndTime"])
final_exam.end_date = strptime(end_string, final_format)
final_exam.clean_fields()
section.final_exam = final_exam
return section
def run(self):
if self.regid is None:
raise Exception("SWSPersonByRegIDThread must have a regid")
self.person = PWS().get_person_by_regid(self.regid)
def test_pws_err(self):
self.assertRaises(DataFailureException,
PWS().get_person_by_netid, "nomockid")
def test_pws_regid_404(self):
with self.settings(RESTCLIENTS_PWS_DAO_CLASS=
'restclients.dao_implementation.errors.Always404'):
pws = PWS()
self.assertRaises(DataFailureException, pws.get_person_by_regid,
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")
