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_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_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 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_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_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_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 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_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 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_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 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 test_pws_err(self):
self.assertRaises(DataFailureException,
PWS().get_person_by_netid, "nomockid")
def test_not_in_pws_netid(self):
self.assertRaises(InvalidNetID,
PWS().get_person_by_netid, "thisisnotarealnetid")
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)
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 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 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")
