def GET(self, request):
"""
GET returns 200 with the student account balances
of the current user
"""
timer = Timer()
try:
profile = get_profile_of_current_user()
response = profile.json_data()
response['display_name'] = get_display_name_of_current_user()
response['campus'] = get_base_campus(request)
response['is_grad_student'] = is_grad_student()
try:
enrollment = get_current_quarter_enrollment(request)
response['class_level'] = enrollment.class_level
if len(enrollment.majors) > 0:
response['majors'] = []
for major in enrollment.majors:
response['majors'].append(major.json_data())
if len(enrollment.minors) > 0:
response['minors'] = []
for minor in enrollment.minors:
response['minors'].append(minor.json_data())
except Exception:
pass
log_success_response(logger, timer)
return HttpResponse(json.dumps(response))
except Exception:
return handle_exception(logger, timer, traceback)
def GET(self, request, year, quarter, summer_term=None):
"""
GET returns 200 with course section schedule details of
the given year, quarter.
Return the course sections of full term and matched term
if a specific summer-term is given
@return class schedule data in json format
status 404: no schedule found (not registered)
status 543: data error
"""
timer = Timer()
try:
smr_term = ""
if summer_term and len(summer_term) > 1:
smr_term = summer_term.title()
request_term = get_specific_term(year, quarter)
if is_past(request_term, request):
if not in_show_grades_period(request_term, request):
log_msg(logger, timer, "Future term has pasted")
return invalid_future_term()
return self.make_http_resp(timer, request_term, request, smr_term)
except Exception:
return handle_exception(logger, timer, traceback)
def get_subject_guide_by_section(section):
"""
returns a url string
"""
if section is None:
return None
get_default = False
section_campus = section.course_campus.lower()
section_logid = "(%s %s %s, %s)" % (section.curriculum_abbr,
section.course_number,
section.section_id,
section_campus)
timer = Timer()
try:
logid = "%s%s" % ('get_subject_guide_for_section',
section_logid)
subject_guide = get_subject_guide_for_section(section)
if subject_guide.is_default_guide:
default_campus = subject_guide.default_guide_campus.lower()
if default_campus != section_campus:
get_default = True
except DataFailureException as ex:
if ex.status == 404:
get_default = True
else:
raise
if get_default:
logid = "%s%s" % ('get_default_subject_guide',
section_logid)
subject_guide = get_default_subject_guide(section_campus)
log_time(logger, logid, timer)
return subject_guide.guide_url
def respond(self, request, year, quarter, summer_term):
timer = Timer()
try:
if not is_student():
log_msg(logger, timer, "Not a student, abort!")
return data_not_found()
term = get_specific_term(year=year, quarter=quarter)
schedule = get_schedule_by_term(request, term)
if summer_term is not None and len(summer_term) > 0:
summer_term = summer_term.replace(",", "")
filter_schedule_sections_by_summer_term(schedule, summer_term)
if len(schedule.sections) == 0:
log_data_not_found_response(logger, timer)
return data_not_found()
book_data = get_textbook_by_schedule(schedule)
by_sln = index_by_sln(book_data)
try:
verba_link = get_verba_link_by_schedule(schedule)
by_sln["verba_link"] = verba_link
except DataFailureException as ex:
if ex.status != 404:
raise
log_success_response(logger, timer)
return HttpResponse(json.dumps(by_sln))
except Exception:
return handle_exception(logger, timer, traceback)
def get_textbook_by_schedule(schedule):
"""
returns textbooks for a valid schedule
"""
timer = Timer()
try:
return Bookstore().get_books_for_schedule(schedule)
finally:
log_resp_time(logger, 'get_books_for_schedule', timer)
def get_verba_link_by_schedule(schedule):
"""
returns a link to the verba price compare page for a valid schedule
"""
timer = Timer()
try:
return Bookstore().get_verba_link_for_schedule(schedule)
finally:
log_resp_time(logger, 'get_verba_link', timer)
def get_current_quarter_enrollment(request):
regid = get_regid_of_current_user()
timer = Timer()
id = "%s %s" % ('get enrollment by regid', regid)
try:
return get_enrollment_by_regid_and_term(regid,
get_current_quarter(request))
finally:
log_resp_time(logger, id, timer)
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 _is_member(groupid):
"""
Return True if the current user netid is
an effective member of the given group
"""
timer = Timer()
try:
return GWS().is_effective_member(groupid,
get_netid_of_current_user())
finally:
log_resp_time(logger,
'gws.is_effective_member of ' + groupid,
timer)
def GET(self, request):
"""
GET returns 200 with the current quarter course section schedule
@return class schedule data in json format
status 404: no schedule found (not registered)
status 543: data error
"""
timer = Timer()
try:
return self.make_http_resp(timer, get_current_quarter(request),
request)
except Exception:
return handle_exception(logger, timer, traceback)
def GET(self, request, year, quarter):
timer = Timer()
try:
no_myplan_access = during_myplan_peak_load(
get_comparison_datetime(request), request)
if no_myplan_access:
log_msg(logger, timer,
"No MyPlan access during their peak load, abort!")
return HttpResponse('[]')
plan = get_plan(regid=get_regid_of_current_user(),
year=year,
quarter=quarter.lower(),
terms=1)
base_json = plan.json_data()
has_ready_courses = False
has_unready_courses = False
ready_count = 0
unready_count = 0
has_sections = False
for course in base_json["terms"][0]["courses"]:
if course["registrations_available"]:
has_ready_courses = True
ready_count = ready_count + 1
for section in course["sections"]:
has_sections = True
curriculum = course["curriculum_abbr"].upper()
section_id = section["section_id"].upper()
label = "%s,%s,%s,%s/%s" % (year, quarter.lower(
), curriculum, course["course_number"], section_id)
sws_section = get_section_by_label(label)
section["section_data"] = sws_section.json_data()
else:
if len(course["sections"]):
has_sections = True
has_unready_courses = True
unready_count = unready_count + 1
base_json["terms"][0]["has_ready_courses"] = has_ready_courses
base_json["terms"][0]["has_unready_courses"] = has_unready_courses
base_json["terms"][0]["ready_count"] = ready_count
base_json["terms"][0]["unready_count"] = unready_count
base_json["terms"][0]["has_sections"] = has_sections
log_success_response(logger, timer)
return HttpResponse(json.dumps(base_json))
except Exception:
log_err(logger, timer, traceback.format_exc())
return HttpResponse('[]')
def GET(self, request):
"""
GET returns 200 with the HFS account balances
of the current user
"""
timer = Timer()
try:
balances = get_account_balances_for_current_user()
resp_json = balances.json_data(use_custom_date_format=True)
log_success_response(logger, timer)
return HttpResponse(json.dumps(resp_json))
except Exception:
return handle_exception(logger, timer, traceback)
def get_canvas_enrolled_courses():
"""
Returns calendar information for the current term.
Raises: DataFailureException
"""
timer = Timer()
try:
regid = get_regid_of_current_user()
return get_indexed_data_for_regid(regid)
except AttributeError:
# If course is not in canvas, skip
return []
finally:
log_resp_time(logger, 'get_canvas_enrolled_courses', timer)
def _get_account_balances_by_regid(user_regid):
"""
returns restclients.models.sws.Finance object for a given regid
"""
if user_regid is None:
return None
timer = Timer()
id = "%s %s" % ('_get_account_balances_by_regid', user_regid)
try:
return get_account_balances_by_regid(user_regid)
finally:
log_resp_time(logger, id, timer)
def GET(self, request):
"""
GET returns 200 with the library account balances
of the current user
"""
timer = Timer()
try:
myaccount = get_account_info_for_current_user()
resp_json = myaccount.json_data(
use_abbr_week_month_day_format=True)
log_success_response(logger, timer)
return HttpResponse(json.dumps(resp_json))
except Exception:
return handle_exception(logger, timer, traceback)
def _get_schedule(regid, term):
"""
@return a restclients.models.sws.ClassSchedule object
Return the actively enrolled sections for the current user
in the given term/quarter
"""
if regid is None or term is None:
return None
logid = ('get_schedule_by_regid_and_term ' + str(regid) + ',' +
str(term.year) + ',' + term.quarter)
timer = Timer()
try:
return get_schedule_by_regid_and_term(regid, term, False)
finally:
log_resp_time(logger, logid, timer)
def GET(self, request):
"""
GET returns 200 with a list of notices for the current user
with an empty array if no notice.
543 for data error
"""
timer = Timer()
try:
notice_json = []
if is_student():
notice_json = get_json_for_notices(
request, get_notices_for_current_user())
log_success_response(logger, timer)
return HttpResponse(json.dumps(notice_json))
except Exception:
return handle_exception(logger, timer, traceback)
def GET(self, request, category_id):
"""
GET returns 200 with links for the given category
"""
timer = Timer()
logger = logging.getLogger('views.api.CategoryLinks.GET')
links = get_links_for_category(category_id, request)
if not links:
log_data_not_found_response(logger, timer)
return data_not_found()
link_data = self._group_links_by_subcategory(links)
category_name = links[0].category_name
log_success_response(logger, timer)
return HttpResponse(
json.dumps({
"link_data": link_data,
"category_name": category_name
}))
def GET(self, request):
"""
GET returns 200 with current thrive message
for the current user if they are a first year student
"""
timer = Timer()
logger = logging.getLogger(__name__)
message = None
if is_thrive_viewer():
if request.GET.get('history', False):
message = get_previous_messages(request)
else:
message = get_current_message(request)
if message is None:
log_data_not_found_response(logger, timer)
return data_not_found()
log_success_response(logger, timer)
return HttpResponse(json.dumps(message))
def _get_notices_by_regid(user_regid):
"""
returns SWS notices for a given regid with
myuw specific categories
"""
if user_regid is None:
return None
timer = Timer()
try:
notices = get_notices_by_regid(user_regid)
if notices is None:
return None
return categorize_notices(notices)
finally:
log_resp_time(logger,
'Notice.get_notices',
timer)
def GET(self, request):
"""
GET returns 200 with the registered future quarters of the current user
if not registered, returns 200 with
the future year & quarter.
543: data error
"""
timer = Timer()
try:
try:
future_quarters = get_registered_future_quarters(request)
except DataFailureException as ex:
if ex.status != 404:
raise
future_quarters = []
resp_data = {"terms": future_quarters}
next_non_summer = get_next_non_summer_quarter(request)
next_year = next_non_summer.year
next_quarter = next_non_summer.quarter
has_registration_for_next_term = False
for term in future_quarters:
if term["quarter"].lower() == next_quarter and\
term["year"] == next_year and\
term["section_count"] > 0:
has_registration_for_next_term = True
resp_data["next_term_data"] = {
"year": next_non_summer.year,
"quarter": next_non_summer.quarter.capitalize(),
"has_registration": has_registration_for_next_term,
}
highlight = should_highlight_future_quarters(
future_quarters, request)
resp_data["highlight_future_quarters"] = highlight
log_success_response(logger, timer)
return HttpResponse(json.dumps(resp_data))
except Exception:
return handle_exception(logger, timer, traceback)
def GET(self, request):
"""
GET returns 200 with the student account balances
of the current user
"""
timer = Timer()
try:
if not is_student():
log_msg(logger, timer, "Not a student, abort!")
return data_not_found()
balances = get_account_balances_for_current_user()
date = get_tuition_due_date()
response = balances.json_data()
response['tuition_due'] = str(date)
log_success_response(logger, timer)
return HttpResponse(json.dumps(response))
except Exception:
return handle_exception(logger, timer, traceback)
def GET(self, request):
"""
GET /api/v1/ias/
"""
timer = Timer()
try:
dao_class = getattr(settings,
"RESTCLIENTS_IASYSTEM_DAO_CLASS",
MOCKDAO)
if dao_class == MOCKDAO and\
get_netid_of_current_user() == "eight":
time.sleep(10)
if not is_student():
log_msg(logger, timer, "Not a student, abort!")
return data_not_found()
if not in_coursevel_fetch_window(request):
# The window starts: 7 days before last inst
# ends: the midnight at the end of current term
# grade submission deadline
log_msg(logger, timer, "Not in fetching window")
return data_not_found()
term = get_current_quarter(request)
schedule = get_schedule_by_term(request, term)
summer_term = get_current_summer_term_in_schedule(
schedule, request)
filter_schedule_sections_by_summer_term(schedule, summer_term)
if len(schedule.sections) == 0:
log_data_not_found_response(logger, time)
return data_not_found()
resp_data = load_course_eval(request, schedule, summer_term)
log_success_response(logger, timer)
return HttpResponse(json.dumps(resp_data))
except Exception:
return handle_exception(logger, timer, traceback)
def get_current_quarter(request):
"""
Return a restclients.models.sws.Term object
for the current quarter refered in the user session.
"""
timer = Timer()
if hasattr(request, 'myuw_current_quarter'):
return request.myuw_current_quarter
try:
comparison_date = get_comparison_date(request)
term = get_term_by_date(comparison_date)
after = get_term_after(term)
if comparison_date > term.grade_submission_deadline.date():
request.myuw_current_quarter = after
return after
request.myuw_current_quarter = term
return term
finally:
log_resp_time(logger,
'get_current_term',
timer)
