Merge pull request #145 from uw-it-aca/qa

Qa

.travis.yml

@@ -12,7 +12,7 @@ before_script:
   - cp travis-ci/manage.py manage.py
   - python manage.py syncdb --noinput
 script:
-  - pep8 myuw_mobile/ --exclude=migrations,myuw_mobile/management,myuw_mobile/test
+  - pep8 myuw_mobile/ --exclude=migrations,myuw_mobile/management
   - jshint myuw_mobile/static/js/  --verbose
   - mocha myuw_mobile/static/js/test/ --recursive
   - coverage run --source=myuw_mobile/ --omit=myuw_mobile/migrations/* manage.py test myuw_mobile

myuw_mobile/dao/card_display_dates.py

@@ -1,136 +1,170 @@
 """
-Generates the 7 booleans used to determine card visibility, based on dates in
-either the current, next, or previous term.
-
+Generates the booleans to determine card visibility,
+based on dates in either the current, next, or previous term.
 https://docs.google.com/document/d/14q26auOLPU34KFtkUmC_bkoo5dAwegRzgpwmZEQMhaU
 """
 
-from restclients.sws import term
 from django.conf import settings
 from datetime import datetime, timedelta
-from myuw_mobile.dao.term import get_comparison_date, get_current_quarter
-from myuw_mobile.dao.term import get_next_quarter
-from restclients.sws.term import get_term_after, get_term_before
+from myuw_mobile.dao.term import get_comparison_date,\
+    get_current_quarter, get_next_quarter,\
+    get_term_after, get_term_before, get_bof_1st_instruction,\
+    get_eof_last_instruction, get_bof_7d_before_last_instruction,\
+    get_eof_7d_after_class_start, get_eof_last_final_exam
 
 
 def get_card_visibilty_date_values(request=None):
     now = get_comparison_date(request)
-    n2 = datetime(now.year, now.month, now.day, 0, 0, 0)
-    values = get_values_by_date(n2, request)
+    after_midnight = datetime(now.year, now.month, now.day,
+                              0, 0, 1)
+    values = get_values_by_date(after_midnight, request)
     set_js_overrides(request, values)
     return values
 
 
 def get_values_by_date(now, request):
-    current_term = get_current_quarter(request)
-    next_term = get_next_quarter(request)
-    term_after_next = get_term_after(next_term)
+    """
+    now is a datetime object of 1 second after the beginning of the day.
+    """
+    last_term = get_term_before(get_current_quarter(request))
+    return {
+        "is_after_7d_before_last_instruction":
+            is_after_7d_before_last_instruction(now, request),
+        "is_after_grade_submission_deadline":
+            is_before_bof_term(now, request),
+        "is_after_last_day_of_classes":
+            is_after_last_day_of_classes(now, request),
+        "is_after_start_of_registration_display_period":
+            is_after_bof_and_before_eof_reg_period(now, request),
+        "is_after_start_of_summer_reg_display_period1":
+            is_after_bof_and_before_eof_summer_reg_period1(now, request),
+        "is_after_start_of_summer_reg_display_periodA":
+            is_after_bof_and_before_eof_summer_reg_periodA(now, request),
+        "is_before_eof_7days_of_term":
+            is_before_eof_7d_after_class_start(now, request),
+        "is_before_end_of_finals_week":
+            is_before_eof_finals_week(now, request),
+        "is_before_end_of_registration_display_period":
+            is_after_bof_and_before_eof_reg_period(now, request),
+        "is_before_end_of_summer_reg_display_periodA":
+            is_after_bof_and_before_eof_summer_reg_periodA(now, request),
+        "is_before_end_of_summer_reg_display_period1":
+            is_after_bof_and_before_eof_summer_reg_period1(now, request),
+        "is_before_first_day_of_term":
+            is_before_bof_term(now, request),
+        "is_before_last_day_of_classes":
+            is_before_last_day_of_classes(now, request),
+        "last_term": "%s,%s" % (last_term.year, last_term.quarter)
+    }
 
-    is_after_grade_submission_deadline = False
-    is_after_last_day_of_classes = False
-    is_after_start_of_registration_display_period = False
-    is_after_start_of_summer_reg_display_period1 = False
-    is_after_start_of_summer_reg_display_periodA = False
-    is_before_end_of_finals_week = False
-    is_before_last_day_of_classes = False
-    is_before_end_of_registration_display_period = False
-    is_before_end_of_summer_reg_display_period1 = False
-    is_before_end_of_summer_reg_display_periodA = False
-    is_before_first_day_of_term = False
-    is_before_eof_7days_of_term = False
-
-    if now.date() < current_term.first_day_quarter:
-        is_before_first_day_of_term = True
-        # We need to see if we're before this term's 1st day - the term
-        # switches at the grade submission deadline.
-        is_after_grade_submission_deadline = True
-
-    if now.date() < current_term.first_day_quarter + timedelta(days=8):
-        # till the end of 7-day (exclude the first day)
-        is_before_eof_7days_of_term = True
-
-    raw_date = current_term.last_day_instruction
-    d = datetime(raw_date.year, raw_date.month, raw_date.day)
-    if now >= d + timedelta(days=1):
-        is_after_last_day_of_classes = True
 
-    term_reg_data = {
-        "after_start": False,
-        "after_summer1_start": False,
-        "after_summerA_start": False,
-    }
+def is_before_bof_term(now, request):
+    """
+    The term switches after the grade submission deadline.
+    @return true if it is before the begining of the 1st day of instruction
+    """
+    return now < get_bof_1st_instruction(request)
 
-    get_reg_data(now, next_term, term_reg_data)
-    # We also need to be able to show this term's registration stuff, because
-    # the period 2 stretches past the grade submission deadline
-    get_reg_data(now, current_term, term_reg_data)
-    # We also need to be able to show the term after next, in spring quarter
-    get_reg_data(now, term_after_next, term_reg_data)
 
-    if term_reg_data["after_start"]:
-        is_after_start_of_registration_display_period = True
-        is_before_end_of_registration_display_period = True
+def is_before_eof_7d_after_class_start(now, request):
+    """
+    @return true if it is before the end of the 7 days
+    after the instruction start day
+    """
+    return now < get_eof_7d_after_class_start(request)
 
-    if term_reg_data["after_summer1_start"]:
-        is_after_start_of_summer_reg_display_period1 = True
-        is_before_end_of_summer_reg_display_period1 = True
 
-    if term_reg_data["after_summerA_start"]:
-        is_after_start_of_summer_reg_display_periodA = True
-        is_before_end_of_summer_reg_display_periodA = True
+def is_after_7d_before_last_instruction(now, request):
+    """
+    @return true if it is after the begining of 7 days
+    before instruction end
+    """
+    return now > get_bof_7d_before_last_instruction(request)
 
-    raw_date = current_term.last_final_exam_date
-    d = datetime(raw_date.year, raw_date.month, raw_date.day)
-    if now < d + timedelta(days=1):
-        is_before_end_of_finals_week = True
 
-    raw_date = current_term.last_day_instruction
-    d = datetime(raw_date.year, raw_date.month, raw_date.day)
-    if now < d + timedelta(days=1):
-        is_before_last_day_of_classes = True
+def is_before_last_day_of_classes(now, request):
+    """
+    @return true if it is before the end of the last day of classes
+    """
+    return now < get_eof_last_instruction(request)
 
-    after_submission = is_after_grade_submission_deadline
-    after_registration = is_after_start_of_registration_display_period
-    before_reg_end = is_before_end_of_registration_display_period
 
-    summerA_start = is_after_start_of_summer_reg_display_periodA
-    summer1_start = is_after_start_of_summer_reg_display_period1
+def is_after_last_day_of_classes(now, request):
+    """
+    @return true if it is on or after the last day of classes
+    """
+    return not is_before_last_day_of_classes(now, request)
 
-    summerA_end = is_before_end_of_summer_reg_display_periodA
-    summer1_end = is_before_end_of_summer_reg_display_period1
 
-    last_term = get_term_before(current_term)
-    return {
-        "is_after_grade_submission_deadline": after_submission,
-        "is_after_last_day_of_classes": is_after_last_day_of_classes,
-        "is_after_start_of_registration_display_period": after_registration,
-        "is_after_start_of_summer_reg_display_periodA": summerA_start,
-        "is_after_start_of_summer_reg_display_period1": summer1_start,
-        "is_before_end_of_finals_week": is_before_end_of_finals_week,
-        "is_before_last_day_of_classes": is_before_last_day_of_classes,
-        "is_before_end_of_registration_display_period": before_reg_end,
-        "is_before_end_of_summer_reg_display_periodA": summerA_end,
-        "is_before_end_of_summer_reg_display_period1": summer1_end,
-        "is_before_first_day_of_term": is_before_first_day_of_term,
-        "is_before_eof_7days_of_term": is_before_eof_7days_of_term,
-        "last_term": "%s,%s" % (last_term.year, last_term.quarter),
+def is_before_eof_finals_week(now, request):
+    """
+    @return true if it is before the end of the last day of finalsweek
+    """
+    return now < get_eof_last_final_exam(request)
+
+
+def is_after_bof_and_before_eof_reg_period(now, request):
+    """
+    @return true if it is after the begining of registration display period,
+    and before the end of registration display period.
+    """
+    reg_data = get_reg_data(now, request)
+    return reg_data["after_start"]
+
+
+def is_after_bof_and_before_eof_summer_reg_period1(now, request):
+    """
+    @return true if it is after the begining of registration display period1,
+    and before the end of registration display period1.
+    """
+    reg_data = get_reg_data(now, request)
+    return reg_data["after_summer1_start"]
+
+
+def is_after_bof_and_before_eof_summer_reg_periodA(now, request):
+    """
+    @return true if it is after the begining of registration display periodA,
+    and before the end of registration display periodA.
+    """
+    reg_data = get_reg_data(now, request)
+    return reg_data["after_summerA_start"]
+
+
+def get_reg_data(now, request):
+    """
+    now is the second after mid-night
+    """
+    term_reg_data = {
+        "after_start": False,
+        "after_summer1_start": False,
+        "after_summerA_start": False,
     }
+    next_term = get_next_quarter(request)
+    get_term_reg_data(now, next_term, term_reg_data)
+    # We need to show this term's registration stuff, because
+    # the period 2 stretches past the grade submission deadline
+    current_term = get_current_quarter(request)
+    get_term_reg_data(now, current_term, term_reg_data)
+    # We also need to be able to show the term after next, in spring quarter
+    term_after_next = get_term_after(next_term)
+    get_term_reg_data(now, term_after_next, term_reg_data)
+    return term_reg_data
 
 
-def get_reg_data(now, term, data):
+def get_term_reg_data(now, term, data):
     if term.quarter == "summer":
-        if (now >= term.registration_period1_start - timedelta(days=7) and
-                now < term.registration_period1_start + timedelta(days=7)):
+        if now >= term.registration_period1_start - timedelta(days=7) and\
+                now < term.registration_period1_start + timedelta(days=7):
             data["after_summerA_start"] = True
             data["before_summerA_end"] = True
 
-        elif (now >= term.registration_period1_start + timedelta(days=7) and
-                now < term.registration_period2_start + timedelta(days=7)):
+        elif now >= term.registration_period1_start + timedelta(days=7) and\
+                now < term.registration_period2_start + timedelta(days=7):
             data["after_summer1_start"] = True
             data["before_summer1_end"] = True
     else:
-        if (now >= term.registration_period1_start - timedelta(days=14) and
-                now < term.registration_period2_start + timedelta(days=7)):
+        if now >= term.registration_period1_start - timedelta(days=14) and\
+                now < term.registration_period2_start + timedelta(days=7):
             data["after_start"] = True
             data["before_end"] = True
 
@@ -146,6 +180,7 @@ def set_js_overrides(request, values):
            'myuw_before_end_of_reg_display': before_reg,
            'myuw_before_first_day': 'is_before_first_day_of_term',
            'myuw_before_end_of_first_week': 'is_before_eof_7days_of_term',
+           'myuw_after_eval_start': 'is_after_7d_before_last_instruction'
            }
 
     for key, value in MAP.iteritems():

myuw_mobile/dao/iasystem.py

@@ -0,0 +1,81 @@
+from datetime import datetime
+from django.utils import timezone
+from restclients.pws import PWS
+from restclients.exceptions import DataFailureException
+from restclients.iasystem import evaluation
+from myuw_mobile.dao.student_profile import get_profile_of_current_user
+from myuw_mobile.dao.term import get_comparison_date, term_matched,\
+    get_bof_7d_before_last_instruction, get_eof_term
+
+
+def get_evaluations_by_section(section):
+    return _get_evaluations_by_section_and_student(
+        section, get_profile_of_current_user().student_number)
+
+
+def _get_evaluations_by_section_and_student(section, student_number):
+    try:
+        search_params = {'year': section.term.year,
+                         'term_name': section.term.quarter.capitalize(),
+                         'curriculum_abbreviation': section.curriculum_abbr,
+                         'course_number': section.course_number,
+                         'section_id': section.section_id,
+                         'student_id': student_number}
+        return evaluation.search_evaluations(section.course_campus.lower(),
+                                             **search_params)
+
+    except DataFailureException:
+        return None
+
+
+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

myuw_mobile/dao/student_profile.py

@@ -15,6 +15,9 @@
 
 
 def get_profile_of_current_user():
+    """
+    Return restclients.models.sws.SwsPerson object
+    """
     regid = get_regid_of_current_user()
 
     timer = Timer()