Add personal review overview page for reviewers, add page for editing

reviewer availability settings, emailing the reviewer/secretary as
necessary, add tests for these pages. Fix a bunch of bugs.
 - Legacy-Id: 11998

Author: OleLaursen

ietf/doc/tests_review.py

@@ -12,7 +12,7 @@
 
 import debug                            # pyflakes:ignore
 
-from ietf.review.models import ReviewRequest, ReviewTeamResult, ReviewerSettings
+from ietf.review.models import ReviewRequest, ReviewTeamResult, ReviewerSettings, ReviewWish, UnavailablePeriod
 import ietf.review.mailarch
 from ietf.person.models import Email, Person
 from ietf.name.models import ReviewResultName, ReviewRequestStateName, ReviewTypeName, DocRelationshipName
@@ -166,9 +166,17 @@ def test_assign_reviewer(self):
 
         reviewer_settings = ReviewerSettings.objects.get(person__email=plain_email)
         reviewer_settings.filter_re = doc.name
-        reviewer_settings.unavailable_until = datetime.datetime.now() + datetime.timedelta(days=10)
         reviewer_settings.save()
 
+        UnavailablePeriod.objects.create(
+            team=review_req.team,
+            person=plain_email.person,
+            start_date=datetime.date.today() - datetime.timedelta(days=10),
+            availability="unavailable",
+        )
+
+        ReviewWish.objects.create(person=plain_email.person, team=review_req.team, doc=doc)
+
         assign_url = urlreverse('ietf.doc.views_review.assign_reviewer', kwargs={ "name": doc.name, "request_id": review_req.pk })
 
 
@@ -188,9 +196,10 @@ def test_assign_reviewer(self):
         plain_label = q("option[value=\"{}\"]".format(plain_email.address)).text().lower()
         self.assertIn("ready for", plain_label)
         self.assertIn("reviewed document before", plain_label)
+        self.assertIn("wishes to review", plain_label)
         self.assertIn("is author", plain_label)
         self.assertIn("regexp matches", plain_label)
-        self.assertIn("unavailable until", plain_label)
+        self.assertIn("unavailable", plain_label)
 
         # assign
         empty_outbox()
@@ -422,6 +431,15 @@ def test_complete_review_upload_content(self):
 
         self.assertTrue(settings.MAILING_LIST_ARCHIVE_URL in review_req.review.external_url)
 
+        # check the review document page
+        url = urlreverse('doc_view', kwargs={ "name": review_req.review.name })
+        r = self.client.get(url)
+        self.assertEqual(r.status_code, 200)
+        content = unicontent(r)
+        self.assertTrue("{} Review".format(review_req.type.name) in content)
+        self.assertTrue("This is a review" in content)
+
+
     def test_complete_review_enter_content(self):
         review_req, url = self.setup_complete_review_test()
 

ietf/group/tests_review.py

@@ -6,10 +6,10 @@
 
 from ietf.utils.test_data import make_test_data, make_review_data
 from ietf.utils.test_utils import login_testing_unauthorized, TestCase, unicontent, reload_db_objects
-from ietf.review.models import ReviewRequest, ReviewRequestStateName
 from ietf.doc.models import TelechatDocEvent
 from ietf.iesg.models import TelechatDate
 from ietf.person.models import Email, Person
+from ietf.review.models import ReviewRequest, ReviewRequestStateName, ReviewerSettings, UnavailablePeriod
 from ietf.review.utils import suggested_review_requests_for_team
 import ietf.group.views_review
 from ietf.utils.mail import outbox, empty_outbox
@@ -190,3 +190,85 @@ def test_email_open_review_assignments(self):
         self.assertEqual(outbox[0]["subject"], "Test subject")
         self.assertTrue("Test body" in unicode(outbox[0]))
 
+    def test_change_reviewer_settings(self):
+        doc = make_test_data()
+
+        reviewer = Person.objects.get(name="Plain Man")
+
+        review_req = make_review_data(doc)
+        review_req.reviewer = reviewer.email_set.first()
+        review_req.save()
+        
+        url = urlreverse(ietf.group.views_review.change_reviewer_settings, kwargs={
+            "group_type": review_req.team.type_id,
+            "acronym": review_req.team.acronym,
+            "reviewer_email": review_req.reviewer_id,
+        })
+
+        login_testing_unauthorized(self, reviewer.user.username, url)
+
+        # get
+        r = self.client.get(url)
+        self.assertEqual(r.status_code, 200)
+
+        # set settings
+        empty_outbox()
+        r = self.client.post(url, {
+            "action": "change_settings",
+            "min_interval": "7",
+            "filter_re": "test-[regexp]",
+            "skip_next": "2",
+        })
+        self.assertEqual(r.status_code, 302)
+        settings = ReviewerSettings.objects.get(person=reviewer, team=review_req.team)
+        self.assertEqual(settings.min_interval, 7)
+        self.assertEqual(settings.filter_re, "test-[regexp]")
+        self.assertEqual(settings.skip_next, 2)
+        self.assertEqual(len(outbox), 1)
+        self.assertTrue("reviewer availability" in outbox[0]["subject"].lower())
+        self.assertTrue("frequency changed", unicode(outbox[0]).lower())
+        self.assertTrue("skip next", unicode(outbox[0]).lower())
+
+        # add unavailable period
+        start_date = datetime.date.today() + datetime.timedelta(days=10)
+        empty_outbox()
+        r = self.client.post(url, {
+            "action": "add_period",
+            'start_date': start_date.isoformat(),
+            'end_date': "",
+            'availability': "unavailable",
+        })
+        self.assertEqual(r.status_code, 302)
+        period = UnavailablePeriod.objects.get(person=reviewer, team=review_req.team, start_date=start_date)
+        self.assertEqual(period.end_date, None)
+        self.assertEqual(period.availability, "unavailable")
+        self.assertEqual(len(outbox), 1)
+        self.assertTrue(start_date.isoformat(), unicode(outbox[0]).lower())
+        self.assertTrue("indefinite", unicode(outbox[0]).lower())
+
+        # end unavailable period
+        empty_outbox()
+        end_date = start_date + datetime.timedelta(days=10)
+        r = self.client.post(url, {
+            "action": "end_period",
+            'period_id': period.pk,
+            'end_date': end_date.isoformat(),
+        })
+        self.assertEqual(r.status_code, 302)
+        period = reload_db_objects(period)
+        self.assertEqual(period.end_date, end_date)
+        self.assertEqual(len(outbox), 1)
+        self.assertTrue(start_date.isoformat(), unicode(outbox[0]).lower())
+        self.assertTrue("indefinite", unicode(outbox[0]).lower())
+
+        # delete unavailable period
+        empty_outbox()
+        r = self.client.post(url, {
+            "action": "delete_period",
+            'period_id': period.pk,
+        })
+        self.assertEqual(r.status_code, 302)
+        self.assertEqual(UnavailablePeriod.objects.filter(person=reviewer, team=review_req.team, start_date=start_date).count(), 0)
+        self.assertEqual(len(outbox), 1)
+        self.assertTrue(start_date.isoformat(), unicode(outbox[0]).lower())
+        self.assertTrue(end_date.isoformat(), unicode(outbox[0]).lower())

ietf/group/urls_info.py

@@ -4,7 +4,7 @@
 from django.views.generic import RedirectView
 from django.conf import settings
 
-from ietf.group import views, views_edit, views_review
+from ietf.group import views, views_edit
 
 urlpatterns = patterns('',
     (r'^$', views.active_groups), 
@@ -21,7 +21,5 @@
     (r'^email-aliases/$', 'ietf.group.views.email_aliases'),
     (r'^bofs/create/$', views_edit.edit, {'action': "create", }, "bof_create"),
     (r'^photos/$', views.chair_photos),
-    (r'^reviews/$', views.review_requests),
-    (r'^reviews/manage/$', views_review.manage_review_requests),
     (r'^%(acronym)s/' % settings.URL_REGEXPS, include('ietf.group.urls_info_details')),
 )

ietf/group/urls_info_details.py

@@ -33,5 +33,7 @@
     (r'^reviews/$', views.review_requests),
     (r'^reviews/manage/$', views_review.manage_review_requests),
     (r'^reviews/email-assignments/$', views_review.email_open_review_assignments),
+    (r'^reviewers/$', views_review.reviewer_overview),
+    (r'^reviewers/(?P<reviewer_email>[\w%+-.@]+)/settings/$', views_review.change_reviewer_settings),
     url(r'^email-aliases/$', RedirectView.as_view(pattern_name='ietf.group.views.email',permanent=False),name='old_group_email_aliases'),
 )

ietf/group/views.py

@@ -70,7 +70,9 @@
 from ietf.meeting.utils import group_sessions
 from ietf.meeting.helpers import get_meeting
 from ietf.review.models import ReviewRequest
-from ietf.review.utils import can_manage_review_requests_for_team, suggested_review_requests_for_team
+from ietf.review.utils import (can_manage_review_requests_for_team,
+                               suggested_review_requests_for_team,
+                               current_unavailable_periods_for_reviewers)
 
 def roles(group, role_name):
     return Role.objects.filter(group=group, name=role_name).select_related("email", "person")
@@ -669,12 +671,17 @@ def review_requests(request, acronym, group_type=None):
         team=group, state__in=("requested", "accepted")
     ).prefetch_related("reviewer", "type", "state").order_by("-time", "-id"))
 
-    open_review_requests += suggested_review_requests_for_team(group)
+    unavailable_periods = current_unavailable_periods_for_reviewers(group)
+    for review_req in open_review_requests:
+        if review_req.reviewer:
+            review_req.reviewer_unavailable = any(p.availability == "unavailable"
+                                                  for p in unavailable_periods.get(review_req.reviewer.person_id, []))
+
+    open_review_requests = suggested_review_requests_for_team(group) + open_review_requests
 
     today = datetime.date.today()
     for r in open_review_requests:
-        delta = today - r.deadline
-        r.due = max(0, delta.days)
+        r.due = max(0, (today - r.deadline).days)
 
     closed_review_requests = ReviewRequest.objects.filter(
         team=group,