if not user.is_authenticated:

return False

if doc.type_id == 'draft' and doc.get_state_slug() != 'active':

return False

return (is_authorized_in_doc_stream(user, doc)

if not user.is_authenticated:

return False

return (Role.objects.filter(name="secr", person__user=user, group=team).exists()

if not user.is_authenticated:

return False

return (Role.objects.filter(name__in=("secr", "reviewer"), person__user=user, group=team).exists()

assignment_qs = ReviewAssignment.objects.filter(

state__in=["assigned", "accepted", "part-completed", "completed"],

).prefetch_related("result")

doc_names = [d.name for d in docs]

return Group.objects.filter(

reviewrequest__doc__name=doc.name,

reviewrequest__requested_rev=rev,

reviewrequest__state__slug="no-review-version",

"""Return dict with currently active unavailable periods for reviewers."""

today = datetime.date.today()

unavailable_period_qs = UnavailablePeriod.objects.filter(

Q(end_date__gte=today) | Q(end_date=None),

Q(start_date__lte=today) | Q(start_date=None),

team=team,

).order_by("end_date")

res = defaultdict(list)

for period in unavailable_period_qs:

res[period.person_id].append(period)

"""Returns person_id -> days needed until min_interval is fulfilled

latest_assignments = dict(ReviewAssignment.objects.filter(

review_request__team=team,

).values_list("reviewer__person").annotate(Max("assigned_on")))

min_intervals = dict(ReviewerSettings.objects.filter(team=team).values_list("person_id", "min_interval"))

now = datetime.datetime.now()

res = {}

for person_id, latest_assignment_time in latest_assignments.items():

if latest_assignment_time is not None:

min_interval = min_intervals.get(person_id)

if min_interval is None:

continue

days_needed = max(0, min_interval - (now - latest_assignment_time).days)

if days_needed > 0:

res[person_id] = days_needed

"""Yield data on each review assignment, sorted by (*ordering, assigned_on)

filters = Q()

if teams:

filters &= Q(review_request__team__in=teams)

if reviewers:

filters &= Q(reviewer__person__in=reviewers)

if time_from:

filters &= Q(review_request__time__gte=time_from)

if time_to:

filters &= Q(review_request__time__lte=time_to)

# This doesn't do the left-outer join on docevent that the previous code did. These variables could be renamed

event_qs = ReviewAssignment.objects.filter(filters)

event_qs = event_qs.values_list(

"pk", "review_request__pk", "review_request__doc__name", "review_request__doc__pages", "review_request__time", "state", "review_request__deadline", "reviewed_rev", "result", "review_request__team",

"reviewer__person", "assigned_on", "completed_on"

)

event_qs = event_qs.order_by(*[o.replace("reviewer", "reviewer__person").replace("team","review_request__team") for o in ordering] + ["review_request__time", "assigned_on", "pk", "completed_on"])

def positive_days(time_from, time_to):

if time_from is None or time_to is None:

return None

delta = time_to - time_from

seconds = delta.total_seconds()

if seconds > 0:

return seconds / float(24 * 60 * 60)

else:

return 0.0

requested_time = assigned_time = closed_time = None

for assignment in event_qs:

assignment_pk, request_pk, doc_name, doc_pages, req_time, state, deadline, reviewed_rev, result, team, reviewer, assigned_on, completed_on = assignment

requested_time = req_time

assigned_time = assigned_on

closed_time = completed_on

late_days = positive_days(datetime.datetime.combine(deadline, datetime.time.max), closed_time)

request_to_assignment_days = positive_days(requested_time, assigned_time)

assignment_to_closure_days = positive_days(assigned_time, closed_time)

request_to_closure_days = positive_days(requested_time, closed_time)

d = ReviewAssignmentData(assignment_pk, request_pk, doc_name, doc_pages, req_time, state, assigned_time, deadline, reviewed_rev, result, team, reviewer,

late_days, request_to_assignment_days, assignment_to_closure_days,

request_to_closure_days)

"""Take a sequence of review request data from

state_dict = defaultdict(int)

late_state_dict = defaultdict(int)

result_dict = defaultdict(int)

assignment_to_closure_days_list = []

assignment_to_closure_days_count = 0

for (assignment_pk, request_pk, doc, doc_pages, req_time, state, assigned_time, deadline, reviewed_rev, result, team, reviewer,

late_days, request_to_assignment_days, assignment_to_closure_days, request_to_closure_days) in review_assignment_data:

if count == "pages":

c = doc_pages

else:

c = 1

state_dict[state] += c

if late_days is not None and late_days > 0:

late_state_dict[state] += c

if state in ("completed", "part-completed"):

result_dict[result] += c

if assignment_to_closure_days is not None:

assignment_to_closure_days_list.append(assignment_to_closure_days)

assignment_to_closure_days_count += c

"""Compute statistics from aggregated review request data for one aggregation point."""

state_dict, late_state_dict, result_dict, assignment_to_closure_days_list, assignment_to_closure_days_count = raw_aggregation

res = {}

res["state"] = state_dict

res["result"] = result_dict

res["open"] = sum(state_dict.get(s, 0) for s in ("assigned", "accepted"))

res["completed"] = sum(state_dict.get(s, 0) for s in ("completed", "part-completed"))

res["not_completed"] = sum(state_dict.get(s, 0) for s in state_dict if s in ("rejected", "withdrawn", "overtaken", "no-response"))

res["open_late"] = sum(late_state_dict.get(s, 0) for s in ("assigned", "accepted"))

res["open_in_time"] = res["open"] - res["open_late"]

res["completed_late"] = sum(late_state_dict.get(s, 0) for s in ("completed", "part-completed"))

res["completed_in_time"] = res["completed"] - res["completed_late"]

res["average_assignment_to_closure_days"] = float(sum(assignment_to_closure_days_list)) / (assignment_to_closure_days_count or 1) if assignment_to_closure_days_list else None

"""Collapse a sequence of aggregations into one aggregation."""

state_dict = defaultdict(int)

late_state_dict = defaultdict(int)

result_dict = defaultdict(int)

assignment_to_closure_days_list = []

assignment_to_closure_days_count = 0

for raw_aggr in raw_aggregations:

i_state_dict, i_late_state_dict, i_result_dict, i_assignment_to_closure_days_list, i_assignment_to_closure_days_count = raw_aggr

for s, v in i_state_dict.items():

state_dict[s] += v

for s, v in i_late_state_dict.items():

late_state_dict[s] += v

for r, v in i_result_dict.items():

result_dict[r] += v

assignment_to_closure_days_list.extend(i_assignment_to_closure_days_list)

assignment_to_closure_days_count += i_assignment_to_closure_days_count

"""Collect and return stats for reviewers on latest assignments, in

extracted_data = extract_review_assignment_data(

teams=[team],

time_from=datetime.date.today() - datetime.timedelta(days=days_back),

ordering=["reviewer"],

)

assignment_data_for_reviewers = {

reviewer: list(reversed(list(req_data_items)))

for reviewer, req_data_items in itertools.groupby(extracted_data, key=lambda data: data.reviewer)

}

to, cc = gather_address_lists(

'review_assignment_changed',

skipped_recipients=[Person.objects.get(name="(System)").formatted_email(), by.email_address()],

doc=review_assignment.review_request.doc,

group=review_assignment.review_request.team,

review_assignment=review_assignment,

skip_review_secretary=not notify_secretary,

skip_review_reviewer=not notify_reviewer,

skip_review_requested_by=not notify_requested_by,

)

if to or cc:

url = urlreverse("ietf.doc.views_review.review_request_forced_login", kwargs={ "name": review_assignment.review_request.doc.name, "request_id": review_assignment.review_request.pk })

url = request.build_absolute_uri(url)

send_mail(request, to, request.user.person.formatted_email(), subject, "review/review_request_changed.txt", {

"review_req_url": url,

"review_req": review_assignment.review_request,

"msg": msg,

"""Notify stakeholders about change, skipping a party if the change

was done by that party."""

(to, cc) = gather_address_lists(

'review_req_changed',

skipped_recipients=[Person.objects.get(name="(System)").formatted_email(), by.email_address()],

doc=review_req.doc,

group=review_req.team,

review_request=review_req,

skip_review_secretary=not notify_secretary,

skip_review_reviewer=not notify_reviewer,

skip_review_requested_by=not notify_requested_by,

)

if cc and not to:

to = cc

cc = []

if to or cc:

url = urlreverse("ietf.doc.views_review.review_request_forced_login", kwargs={ "name": review_req.doc.name, "request_id": review_req.pk })

url = request.build_absolute_uri(url)

send_mail(request, to, request.user.person.formatted_email(), subject, "review/review_request_changed.txt", {

"review_req_url": url,

"review_req": review_req,

"msg": msg,

},

cc=cc,

"""Notify possibly both secretary and reviewer about change, skipping

(to, cc) = gather_address_lists(

'review_availability_changed',

skipped_recipients=[Person.objects.get(name="(System)").formatted_email(), by.email_address()],

group=team,

reviewer=reviewer_role,

)

if to or cc:

subject = "Reviewer availability of {} changed in {}".format(reviewer_role.person, team.acronym)

url = urlreverse("ietf.group.views.reviewer_overview", kwargs={ "group_type": team.type_id, "acronym": team.acronym })

url = request.build_absolute_uri(url)

send_mail(request, to, None, subject, "review/reviewer_availability_changed.txt", {

"reviewer_overview_url": url,

"reviewer": reviewer_role.person,

"team": team,

"msg": msg,

"by": by,

assert review_req.state_id in ("requested", "assigned")

# In the original implementation, review unassignments could be made on formsets by setting reviewers to None.

# After refactoring to explicitly model ReviewAssignments, this no longer makes sense. Unassignment is now done

# with a different view on a ReviewAssignment.

log.assertion('reviewer is not None')

if review_req.reviewassignment_set.filter(reviewer=reviewer).exists():

return

# Note that assigning a review no longer unassigns other reviews

if review_req.state_id != 'assigned':

review_req.state_id = 'assigned'

review_req.save()

from ietf.review.policies import get_reviewer_queue_policy

assignment = get_reviewer_queue_policy(review_req.team).assign_reviewer(review_req, reviewer, add_skip)

descr = "Request for {} review by {} is assigned to {}".format(

review_req.type.name,

review_req.team.acronym.upper(),

reviewer.person if reviewer else "(None)")

update_change_reason(assignment, descr)

ReviewRequestDocEvent.objects.create(

type="assigned_review_request",

doc=review_req.doc,

rev=review_req.doc.rev,

by=request.user.person,

desc=descr,

review_request=review_req,

state_id='assigned',

)

ReviewAssignmentDocEvent.objects.create(

type="assigned_review_request",

doc=review_req.doc,

rev=review_req.doc.rev,

by=request.user.person,

desc="Request for {} review by {} is assigned to {}".format(

review_req.type.name,

review_req.team.acronym.upper(),

reviewer.person,

),

review_assignment=assignment,

state_id='assigned',

)

prev_team_reviews = ReviewAssignment.objects.filter(

review_request__doc=review_req.doc,

state="completed",

review_request__team=review_req.team,

)

try:

template = DBTemplate.objects.get(

path="/group/%s/email/review_assigned.txt" % review_req.team.acronym)

except DBTemplate.DoesNotExist:

template = DBTemplate.objects.get(path="/group/defaults/email/review_assigned.txt")

context = {'assigner': request.user.person, 'reviewer': reviewer, 'prev_team_reviews': prev_team_reviews}

msg = render_to_string(template.path, context, request=request)

email_review_request_change(

request, review_req,

"%s %s assignment: %s" % (review_req.team.acronym.capitalize(), review_req.type.name,review_req.doc.name),

msg ,

suggested_req = review_req.pk is None

review_req.state = close_state

review_req.save()

if not suggested_req:

descr = "Closed request for {} review by {} with state '{}'".format(

review_req.type.name, review_req.team.acronym.upper(), close_state.name)

if close_comment:

descr += ': ' + close_comment

update_change_reason(review_req, descr)

ReviewRequestDocEvent.objects.create(

type="closed_review_request",

doc=review_req.doc,

rev=review_req.doc.rev,

by=request.user.person,

desc=descr,

review_request=review_req,

state=review_req.state,

)

for assignment in review_req.reviewassignment_set.filter(state_id__in=['assigned','accepted']):

assignment.state_id = 'withdrawn'

assignment.save()

ReviewAssignmentDocEvent.objects.create(

type='closed_review_assignment',

doc=review_req.doc,

rev=review_req.doc.rev,

by=request.user.person,

desc="Request closed, assignment withdrawn: {} {} {} review".format(assignment.reviewer.person.plain_name(), assignment.review_request.type.name, assignment.review_request.team.acronym.upper()),

review_assignment=assignment,

state=assignment.state,

)

msg = "Review request has been closed by {}.".format(request.user.person)

if close_comment:

msg += "\nComment: {}".format(close_comment)

email_review_request_change(

request, review_req,

"Closed review request for {}: {}".format(review_req.doc.name, close_state.name),

msg=msg, by=request.user.person, notify_secretary=True,

if not team.reviewteamsettings.autosuggest:

return []

system_person = Person.objects.get(name="(System)")

seen_deadlines = {}

requests = {}

now = datetime.datetime.now()

reviewable_docs_qs = Document.objects.filter(type="draft").exclude(stream="ise")

requested_state = ReviewRequestStateName.objects.get(slug="requested", used=True)

last_call_type = ReviewTypeName.objects.get(slug="lc")

if last_call_type in team.reviewteamsettings.review_types.all():

# in Last Call

last_call_docs = reviewable_docs_qs.filter(

states=State.objects.get(type="draft-iesg", slug="lc", used=True)

)

last_call_expiry_events = { e.doc_id: e for e in LastCallDocEvent.objects.order_by("time", "id") }

for doc in last_call_docs:

e = last_call_expiry_events[doc.pk] if doc.pk in last_call_expiry_events else LastCallDocEvent(expires=now, time=now)

deadline = e.expires.date()

if deadline > seen_deadlines.get(doc.pk, datetime.date.max) or deadline < now.date():

continue

requests[doc.pk] = ReviewRequest(

time=e.time,

type=last_call_type,

doc=doc,

team=team,

deadline=deadline,

requested_by=system_person,

state=requested_state,

)

seen_deadlines[doc.pk] = deadline

telechat_type = ReviewTypeName.objects.get(slug="telechat")

if telechat_type in team.reviewteamsettings.review_types.all():

# on Telechat Agenda

telechat_dates = list(TelechatDate.objects.active().order_by('date').values_list("date", flat=True)[:4])

telechat_deadline_delta = datetime.timedelta(days=2)

telechat_docs = reviewable_docs_qs.filter(

docevent__telechatdocevent__telechat_date__in=telechat_dates

)

# we need to check the latest telechat event for each document

# scheduled for the telechat, as the appearance might have been

# cancelled/moved

telechat_events = TelechatDocEvent.objects.filter(

# turn into list so we don't get a complex and slow join sent down to the DB

doc__id__in=list(telechat_docs.values_list("pk", flat=True)),

).values_list(

"doc", "pk", "time", "telechat_date"

).order_by("doc", "-time", "-id").distinct()

for doc_pk, events in itertools.groupby(telechat_events, lambda t: t[0]):

_, _, event_time, event_telechat_date = list(events)[0]

deadline = None

if event_telechat_date in telechat_dates:

deadline = event_telechat_date - telechat_deadline_delta

if not deadline or deadline > seen_deadlines.get(doc_pk, datetime.date.max):

continue

if doc_pk in requests:

# Document was already added in last call, i.e. it is both in last call and telechat

requests[doc_pk].in_lc_and_telechat = True

else:

requests[doc_pk] = ReviewRequest(

time=event_time,

type=telechat_type,

doc_id=doc_pk,

team=team,

deadline=deadline,

requested_by=system_person,

state=requested_state,

)

seen_deadlines[doc_pk] = deadline

# filter those with existing explicit requests

existing_requests = defaultdict(list)

for r in ReviewRequest.objects.filter(doc__id__in=iter(requests.keys()), team=team):

existing_requests[r.doc_id].append(r)

def blocks(existing, request):

if existing.doc_id != request.doc_id:

return False

no_review_document = existing.state_id == "no-review-document"

no_review_rev = ( existing.state_id == "no-review-version") and (not existing.requested_rev or existing.requested_rev == request.doc.rev)

pending = (existing.state_id == "assigned"

and existing.reviewassignment_set.filter(state_id__in=("assigned", "accepted")).exists()

and (not existing.requested_rev or existing.requested_rev == request.doc.rev))

request_closed = existing.state_id not in ('requested','assigned')

# at least one assignment was completed for the requested version or the current doc version if no specific version was requested:

some_assignment_completed = existing.reviewassignment_set.filter(reviewed_rev=existing.requested_rev or existing.doc.rev, state_id='completed').exists()

return any([no_review_document, no_review_rev, pending, request_closed, some_assignment_completed])

res = [r for r in requests.values()

if not any(blocks(e, r) for e in existing_requests[r.doc_id])]

res.sort(key=lambda r: (r.deadline, r.doc_id), reverse=True)

"""Extracts all review assignments for document names (including replaced ancestors), return them neatly sorted."""

names = set(names)

replaces = extract_complete_replaces_ancestor_mapping_for_docs(names)

assignments_for_each_doc = defaultdict(list)

replacement_name_set = set(e for l in replaces.values() for e in l) | names

for r in ( review_assignment_queryset.filter(review_request__doc__name__in=replacement_name_set)

.order_by("-reviewed_rev","-assigned_on", "-id").iterator()):

assignments_for_each_doc[r.review_request.doc.name].append(r)

# now collect in breadth-first order to keep the revision order intact

res = defaultdict(list)

for name in names:

front = replaces.get(name, [])

res[name].extend(assignments_for_each_doc.get(name, []))

seen = set()

while front:

replaces_assignments = []

next_front = []

for replaces_name in front:

if replaces_name in seen:

continue

seen.add(replaces_name)

assignments = assignments_for_each_doc.get(replaces_name, [])

if assignments:

replaces_assignments.append(assignments)

next_front.extend(replaces.get(replaces_name, []))

# in case there are multiple replaces, move the ones with

# the latest reviews up front

replaces_assignments.sort(key=lambda l: l[0].assigned_on, reverse=True)

for assignments in replaces_assignments:

res[name].extend(assignments)

# move one level down

front = next_front

"""Extracts all review requests for document names (including replaced ancestors), return them neatly sorted."""

names = set(names)

replaces = extract_complete_replaces_ancestor_mapping_for_docs(names)

requests_for_each_doc = defaultdict(list)

for r in review_request_queryset.filter(doc__name__in=set(e for l in replaces.values() for e in l) | names).order_by("-time", "-id").iterator():

requests_for_each_doc[r.doc.name].append(r)

# now collect in breadth-first order to keep the revision order intact

res = defaultdict(list)

for name in names:

front = replaces.get(name, [])

res[name].extend(requests_for_each_doc.get(name, []))

seen = set()

while front:

replaces_reqs = []

next_front = []

for replaces_name in front:

if replaces_name in seen:

continue

seen.add(replaces_name)

reqs = requests_for_each_doc.get(replaces_name, [])

if reqs:

replaces_reqs.append(reqs)

next_front.extend(replaces.get(replaces_name, []))

# in case there are multiple replaces, move the ones with

# the latest reviews up front

replaces_reqs.sort(key=lambda l: l[0].time, reverse=True)

for reqs in replaces_reqs:

res[name].extend(reqs)

# move one level down

front = next_front

if type(person) != Person:

person = Person.objects.get(id=person)

groups_to_avoid = [ r.group for r in person.role_set.all() if r.name in r.group.features.groupman_roles and r.group.features.acts_like_wg ]

if not groups_to_avoid:

return '^draft-%s-.*$' % ( person.last_name().lower(), )

else:

reminder_days = 3

end_date = remind_date + datetime.timedelta(days=reminder_days)

min_start_date = end_date - datetime.timedelta(days=30)

periods = UnavailablePeriod.objects.filter(start_date__lte=min_start_date, end_date=end_date)

log = []

for period in periods:

(to, cc) = gather_address_lists('review_availability_changed', group=period.team, reviewer=period.person)

domain = Site.objects.get_current().domain

url = urlreverse("ietf.group.views.reviewer_overview", kwargs={ "group_type": period.team.type_id, "acronym": period.team.acronym })

subject = "Reminder: unavailability period of {} is ending soon".format(period.person)

send_mail(None, to, None, subject, "review/reviewer_unavailability_ending.txt", {

"reviewer_overview_url": "https://{}{}".format(domain, url),

"reviewer": period.person,

"team": period.team,

"reminder_days": reminder_days,

"period_start": period.start_date.isoformat(),

"period_end": period.end_date.isoformat(),

}, cc=cc)

log.append("Emailed reminder to {} for ending of unavailability "

"of {} in {} soon (unavailability period id {})".format(

to, period.person, period.team.acronym,period.pk))

min_overdue_days = 5

min_deadline = remind_date - datetime.timedelta(days=min_overdue_days)

teams = Group.objects.exclude(reviewteamsettings=None)

log = []

for team in teams:

assignments = ReviewAssignment.objects.filter(

state__in=("assigned", "accepted"),

review_request__deadline__lte=min_deadline,

review_request__team=team,

)

if not assignments:

continue

(to, cc) = gather_address_lists('review_reminder_overdue_assignment', group=team)

domain = Site.objects.get_current().domain

subject = "{} Overdue review{} for team {}".format(

len(assignments), pluralize(len(assignments)), team.acronym)

send_mail(None, to, None, subject, "review/review_reminder_overdue_assignment.txt", {

"domain": domain,

"assignments": assignments,

"team": team,

"min_overdue_days": min_overdue_days,

}, cc=cc)

log.append("Emailed reminder to {} about {} overdue reviews in {}".format(

to, assignments.count(), team.acronym,

))

log = []

days_since_origin = (remind_date - ORIGIN_DATE_PERIODIC_REMINDERS).days

relevant_reviewer_settings = ReviewerSettings.objects.filter(remind_days_open_reviews__isnull=False)

for reviewer_settings in relevant_reviewer_settings:

if days_since_origin % reviewer_settings.remind_days_open_reviews != 0:

continue

assignments = ReviewAssignment.objects.filter(

state__in=("assigned", "accepted"),

reviewer__person=reviewer_settings.person,

review_request__team=reviewer_settings.team,

)

if not assignments:

continue

to = reviewer_settings.person.formatted_email()

subject = "Reminder: you have {} open review assignment{}".format(len(assignments), pluralize(len(assignments)))

domain = Site.objects.get_current().domain

url = urlreverse("ietf.group.views.reviewer_overview",

kwargs={"group_type": reviewer_settings.team.type_id,

"acronym": reviewer_settings.team.acronym})

send_mail(None, to, None, subject, "review/reviewer_reminder_all_open_reviews.txt", {

"reviewer_overview_url": "https://{}{}".format(domain, url),

"assignments": assignments,

"team": reviewer_settings.team,

"remind_days": reviewer_settings.remind_days_open_reviews,

})

log.append("Emailed reminder to {} of their {} open reviews".format(to, len(assignments)))

"""

log = []

relevant_review_team_settings = ReviewTeamSettings.objects.filter(

remind_days_unconfirmed_assignments__isnull=False)

for review_team_settings in relevant_review_team_settings:

assignments = ReviewAssignment.objects.filter(

state='assigned',

review_request__team=review_team_settings.group,

)

if not assignments:

continue

for assignment in assignments:

days_old = (remind_date - assignment.assigned_on.date()).days

if days_old == 0 or (days_old % review_team_settings.remind_days_unconfirmed_assignments) != 0:

continue # skip those created today or not due for a reminder today

to = assignment.reviewer.formatted_email()

subject = "Reminder: you have not responded to a review assignment"

domain = Site.objects.get_current().domain

review_request_url = urlreverse("ietf.doc.views_review.review_request", kwargs={

"name": assignment.review_request.doc.name,

"request_id": assignment.review_request.pk

})

cc = [secr_role.formatted_email()

for secr_role in assignment.review_request.team.role_set.filter(name__slug='secr')]

send_mail(

request=None,

to=to,

cc=cc,

frm=None,

subject=subject,

template="review/reviewer_reminder_unconfirmed_assignments.txt",

context={

"review_request_url": "https://{}{}".format(domain, review_request_url),

"assignment": assignment,

"team": assignment.review_request.team,

"remind_days": review_team_settings.remind_days_unconfirmed_assignments,

},

)

log.append("Emailed reminder to {} about not accepted/rejected review assignment {}".format(to, assignment.pk))

"""Get review assignments needing reviewer reminders

assignment_qs = ReviewAssignment.objects.filter(

state__in=("assigned", "accepted"),

reviewer__person__reviewersettings__remind_days_before_deadline__isnull=False,

reviewer__person__reviewersettings__team=F("review_request__team"),

).values_list("pk", "review_request__deadline", "reviewer__person__reviewersettings__remind_days_before_deadline").distinct()

assignment_pks = []

for a_pk, deadline, remind_days in assignment_qs:

if (deadline - remind_date).days == remind_days:

assignment_pks.append(a_pk)

review_request = assignment.review_request

team = review_request.team

deadline_days = (review_request.deadline - datetime.date.today()).days

subject = "Reminder: deadline for review of {} in {} is {}".format(review_request.doc.name, team.acronym, review_request.deadline.isoformat())

import ietf.ietfauth.views

overview_url = urlreverse(ietf.ietfauth.views.review_overview)

import ietf.doc.views_review

request_url = urlreverse(ietf.doc.views_review.review_request, kwargs={ "name": review_request.doc.name, "request_id": review_request.pk })

domain = Site.objects.get_current().domain

settings = ReviewerSettings.objects.filter(person=assignment.reviewer.person, team=team).first()

remind_days = settings.remind_days_before_deadline if settings else 0

send_mail(None, [assignment.reviewer.formatted_email()], None, subject, "review/reviewer_reminder.txt", {

"reviewer_overview_url": "https://{}{}".format(domain, overview_url),

"review_request_url": "https://{}{}".format(domain, request_url),

"review_request": review_request,

"deadline_days": deadline_days,

"remind_days": remind_days,

"""Find ReviewAssignments whose secretary should be sent a reminder today"""

# Get ReviewAssignments for teams whose secretaries have a non-null remind_days_before_deadline

# setting.

assignment_qs = ReviewAssignment.objects.filter(

state__in=("assigned", "accepted"),

review_request__team__role__name__slug='secr',

review_request__team__role__person__reviewsecretarysettings__remind_days_before_deadline__isnull=False,

review_request__team__role__person__reviewsecretarysettings__team=F("review_request__team"),

).exclude(

reviewer=None

).values_list("pk", "review_request__deadline", "review_request__team__role", "review_request__team__role__person__reviewsecretarysettings__remind_days_before_deadline").distinct()

# For each assignment, find all secretaries who should be reminded today

assignment_pks = set()

secretary_pks = set()

notifications = []

for a_pk, deadline, secretary_role_pk, remind_days in assignment_qs:

if (deadline - remind_date).days == remind_days:

notifications.append((a_pk, secretary_role_pk))

assignment_pks.add(a_pk)

secretary_pks.add(secretary_role_pk)

review_assignments = {

a.pk: a

for a in ReviewAssignment.objects.filter(pk__in=assignment_pks).select_related(

"reviewer", "reviewer__person", "state", "review_request__team"

)

}

secretary_roles = {

r.pk: r

for r in Role.objects.filter(pk__in=secretary_pks).select_related("email", "person")

}

return [

(review_assignments[a_pk], secretary_roles[secretary_role_pk])

for a_pk, secretary_role_pk in notifications

review_request = assignment.review_request

team = review_request.team

deadline_days = (review_request.deadline - datetime.date.today()).days

subject = "Reminder: deadline for review of {} in {} is {}".format(review_request.doc.name, team.acronym, review_request.deadline.isoformat())

import ietf.group.views

settings_url = urlreverse(ietf.group.views.change_review_secretary_settings, kwargs={ "acronym": team.acronym, "group_type": team.type_id })

import ietf.doc.views_review

request_url = urlreverse(ietf.doc.views_review.review_request, kwargs={ "name": review_request.doc.name, "request_id": review_request.pk })

domain = Site.objects.get_current().domain

settings = ReviewSecretarySettings.objects.filter(person=secretary_role.person_id, team=team).first()

remind_days = settings.remind_days_before_deadline if settings else 0

send_mail(None, [secretary_role.email.formatted_email()], None, subject, "review/secretary_reminder.txt", {

"review_request_url": "https://{}{}".format(domain, request_url),

"settings_url": "https://{}{}".format(domain, settings_url),

"review_request": review_request,

"deadline_days": deadline_days,

"remind_days": remind_days,