Open Source Monorail

appengine/monorail/features/notify.py

+# Copyright 2016 The Chromium Authors. All rights reserved.
+# Use of this source code is govered by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+"""Task handlers for email notifications of issue changes.
+
+Email notificatons are sent when an issue changes, an issue that is blocking
+another issue changes, or a bulk edit is done.  The users notified include
+the project-wide mailing list, issue owners, cc'd users, starrers,
+also-notify addresses, and users who have saved queries with email notification
+set.
+"""
+
+import collections
+import logging
+
+from third_party import ezt
+
+from google.appengine.api import mail
+from google.appengine.api import taskqueue
+
+import settings
+from features import autolink
+from features import notify_helpers
+from framework import emailfmt
+from framework import framework_bizobj
+from framework import framework_constants
+from framework import framework_helpers
+from framework import framework_views
+from framework import jsonfeed
+from framework import monorailrequest
+from framework import permissions
+from framework import template_helpers
+from framework import urls
+from tracker import component_helpers
+from tracker import tracker_bizobj
+from tracker import tracker_helpers
+from tracker import tracker_views
+
+
+TEMPLATE_PATH = framework_constants.TEMPLATE_PATH
+
+
+def PrepareAndSendIssueChangeNotification(
+    project_id, local_id, hostport, commenter_id, seq_num, send_email=True,
+    old_owner_id=framework_constants.NO_USER_SPECIFIED):
+  """Create a task to notify users that an issue has changed.
+
+  Args:
+    project_id: int ID of the project containing the changed issue.
+    local_id: Issue number for the issue that was updated and saved.
+    hostport: string domain name and port number from the HTTP request.
+    commenter_id: int user ID of the user who made the comment.
+    seq_num: int index into the comments of the new comment.
+    send_email: True if email notifications should be sent.
+    old_owner_id: optional user ID of owner before the current change took
+      effect. He/she will also be notified.
+
+  Returns nothing.
+  """
+  params = dict(
+      project_id=project_id, id=local_id, commenter_id=commenter_id,
+      seq=seq_num, hostport=hostport,
+      old_owner_id=old_owner_id, send_email=int(send_email))
+  logging.info('adding notify task with params %r', params)
+  taskqueue.add(url=urls.NOTIFY_ISSUE_CHANGE_TASK + '.do', params=params)
+
+
+def PrepareAndSendIssueBlockingNotification(
+    project_id, hostport, local_id, delta_blocker_iids,
+    commenter_id, send_email=True):
+  """Create a task to follow up on an issue blocked_on change."""
+  if not delta_blocker_iids:
+    return  # No notification is needed
+
+  params = dict(
+      project_id=project_id, id=local_id, commenter_id=commenter_id,
+      hostport=hostport, send_email=int(send_email),
+      delta_blocker_iids=','.join(str(iid) for iid in delta_blocker_iids))
+
+  logging.info('adding blocking task with params %r', params)
+  taskqueue.add(url=urls.NOTIFY_BLOCKING_CHANGE_TASK + '.do', params=params)
+
+
+def SendIssueBulkChangeNotification(
+    hostport, project_id, local_ids, old_owner_ids,
+    comment_text, commenter_id, amendments, send_email, users_by_id):
+  """Create a task to follow up on an issue blocked_on change."""
+  amendment_lines = []
+  for up in amendments:
+    line = '    %s: %s' % (
+        tracker_bizobj.GetAmendmentFieldName(up),
+        tracker_bizobj.AmendmentString(up, users_by_id))
+    if line not in amendment_lines:
+      amendment_lines.append(line)
+
+  params = dict(
+      project_id=project_id, commenter_id=commenter_id,
+      hostport=hostport, send_email=int(send_email),
+      ids=','.join(str(lid) for lid in local_ids),
+      old_owner_ids=','.join(str(uid) for uid in old_owner_ids),
+      comment_text=comment_text, amendments='\n'.join(amendment_lines))
+
+  logging.info('adding bulk task with params %r', params)
+  taskqueue.add(url=urls.NOTIFY_BULK_CHANGE_TASK + '.do', params=params)
+
+
+def _EnqueueOutboundEmail(message_dict):
+  """Create a task to send one email message, all fields are in the dict.
+
+  We use a separate task for each outbound email to isolate errors.
+
+  Args:
+    message_dict: dict with all needed info for the task.
+  """
+  logging.info('Queuing an email task with params %r', message_dict)
+  taskqueue.add(
+      url=urls.OUTBOUND_EMAIL_TASK + '.do', params=message_dict,
+      queue_name='outboundemail')
+
+
+def AddAllEmailTasks(tasks):
+  """Add one GAE task for each email to be sent."""
+  notified = []
+  for task in tasks:
+    _EnqueueOutboundEmail(task)
+    notified.append(task['to'])
+
+  return notified
+
+
+class NotifyTaskBase(jsonfeed.InternalTask):
+  """Abstract base class for notification task handler."""
+
+  _EMAIL_TEMPLATE = None  # Subclasses must override this.
+
+  CHECK_SECURITY_TOKEN = False
+
+  def __init__(self, *args, **kwargs):
+    super(NotifyTaskBase, self).__init__(*args, **kwargs)
+
+    if not self._EMAIL_TEMPLATE:
+      raise Exception('Subclasses must override _EMAIL_TEMPLATE.'
+                      ' This class must not be called directly.')
+    # We use FORMAT_RAW for emails because they are plain text, not HTML.
+    # TODO(jrobbins): consider sending HTML formatted emails someday.
+    self.email_template = template_helpers.MonorailTemplate(
+        TEMPLATE_PATH + self._EMAIL_TEMPLATE,
+        compress_whitespace=False, base_format=ezt.FORMAT_RAW)
+
+
+class NotifyIssueChangeTask(NotifyTaskBase):
+  """JSON servlet that notifies appropriate users after an issue change."""
+
+  _EMAIL_TEMPLATE = 'tracker/issue-change-notification-email.ezt'
+
+  def HandleRequest(self, mr):
+    """Process the task to notify users after an issue change.
+
+    Args:
+      mr: common information parsed from the HTTP request.
+
+    Returns:
+      Results dictionary in JSON format which is useful just for debugging.
+      The main goal is the side-effect of sending emails.
+    """
+    project_id = mr.specified_project_id
+    if project_id is None:
+      return {
+          'params': {},
+          'notified': [],
+          'message': 'Cannot proceed without a valid project ID.',
+      }
+    commenter_id = mr.GetPositiveIntParam('commenter_id')
+    seq_num = mr.seq
+    omit_ids = [commenter_id]
+    hostport = mr.GetParam('hostport')
+    old_owner_id = mr.GetPositiveIntParam('old_owner_id')
+    send_email = bool(mr.GetIntParam('send_email'))
+    params = dict(
+        project_id=project_id, local_id=mr.local_id, commenter_id=commenter_id,
+        seq_num=seq_num, hostport=hostport, old_owner_id=old_owner_id,
+        omit_ids=omit_ids, send_email=send_email)
+
+    logging.info('issue change params are %r', params)
+    project = self.services.project.GetProject(mr.cnxn, project_id)
+    config = self.services.config.GetProjectConfig(mr.cnxn, project_id)
+    issue = self.services.issue.GetIssueByLocalID(
+        mr.cnxn, project_id, mr.local_id)
+
+    if issue.is_spam:
+      # Don't send email for spam issues.
+      return {
+          'params': params,
+          'notified': [],
+      }
+
+    all_comments = self.services.issue.GetCommentsForIssue(
+        mr.cnxn, issue.issue_id)
+    comment = all_comments[seq_num]
+
+    # Only issues that any contributor could view sent to mailing lists.
+    contributor_could_view = permissions.CanViewIssue(
+        set(), permissions.CONTRIBUTOR_ACTIVE_PERMISSIONSET,
+        project, issue)
+    starrer_ids = self.services.issue_star.LookupItemStarrers(
+        mr.cnxn, issue.issue_id)
+    users_by_id = framework_views.MakeAllUserViews(
+        mr.cnxn, self.services.user,
+        tracker_bizobj.UsersInvolvedInIssues([issue]), [old_owner_id],
+        tracker_bizobj.UsersInvolvedInComment(comment),
+        issue.cc_ids, issue.derived_cc_ids, starrer_ids, omit_ids)
+
+    # Make followup tasks to send emails
+    tasks = []
+    if send_email:
+      tasks = self._MakeEmailTasks(
+          mr.cnxn, project, issue, config, old_owner_id, users_by_id,
+          all_comments, comment, starrer_ids, contributor_could_view,
+          hostport, omit_ids)
+
+    notified = AddAllEmailTasks(tasks)
+
+    return {
+        'params': params,
+        'notified': notified,
+        }
+
+  def _MakeEmailTasks(
+      self, cnxn, project, issue, config, old_owner_id,
+      users_by_id, all_comments, comment, starrer_ids,
+      contributor_could_view, hostport, omit_ids):
+    """Formulate emails to be sent."""
+    detail_url = framework_helpers.IssueCommentURL(
+        hostport, project, issue.local_id, seq_num=comment.sequence)
+
+    # TODO(jrobbins): avoid the need to make a MonorailRequest object.
+    mr = monorailrequest.MonorailRequest()
+    mr.project_name = project.project_name
+    mr.project = project
+
+    # We do not autolink in the emails, so just use an empty
+    # registry of autolink rules.
+    # TODO(jrobbins): offer users an HTML email option w/ autolinks.
+    autolinker = autolink.Autolink()
+
+    email_data = {
+        # Pass open_related and closed_related into this method and to
+        # the issue view so that we can show it on new issue email.
+        'issue': tracker_views.IssueView(issue, users_by_id, config),
+        'summary': issue.summary,
+        'comment': tracker_views.IssueCommentView(
+            project.project_name, comment, users_by_id,
+            autolinker, {}, mr, issue),
+        'comment_text': comment.content,
+        'detail_url': detail_url,
+        }
+
+    # Generate two versions of email body: members version has all
+    # full email addresses exposed.
+    body_for_non_members = self.email_template.GetResponse(email_data)
+    framework_views.RevealAllEmails(users_by_id)
+    email_data['comment'] = tracker_views.IssueCommentView(
+        project.project_name, comment, users_by_id,
+        autolinker, {}, mr, issue)
+    body_for_members = self.email_template.GetResponse(email_data)
+
+    subject = 'Issue %d in %s: %s' % (
+        issue.local_id, project.project_name, issue.summary)
+
+    commenter_email = users_by_id[comment.user_id].email
+    omit_addrs = set([commenter_email] +
+                     [users_by_id[omit_id].email for omit_id in omit_ids])
+
+    auth = monorailrequest.AuthData.FromUserID(
+        cnxn, comment.user_id, self.services)
+    commenter_in_project = framework_bizobj.UserIsInProject(
+        project, auth.effective_ids)
+    noisy = tracker_helpers.IsNoisy(len(all_comments) - 1, len(starrer_ids))
+
+    # Get the transitive set of owners and Cc'd users, and their proxies.
+    reporter = [issue.reporter_id] if issue.reporter_id in starrer_ids else []
+    old_direct_owners, old_transitive_owners = (
+        self.services.usergroup.ExpandAnyUserGroups(cnxn, [old_owner_id]))
+    direct_owners, transitive_owners = (
+        self.services.usergroup.ExpandAnyUserGroups(cnxn, [issue.owner_id]))
+    der_direct_owners, der_transitive_owners = (
+        self.services.usergroup.ExpandAnyUserGroups(
+            cnxn, [issue.derived_owner_id]))
+    direct_comp, trans_comp = self.services.usergroup.ExpandAnyUserGroups(
+        cnxn, component_helpers.GetComponentCcIDs(issue, config))
+    direct_ccs, transitive_ccs = self.services.usergroup.ExpandAnyUserGroups(
+        cnxn, list(issue.cc_ids))
+    # TODO(jrobbins): This will say that the user was cc'd by a rule when it
+    # was really added to the derived_cc_ids by a component.
+    der_direct_ccs, der_transitive_ccs = (
+        self.services.usergroup.ExpandAnyUserGroups(
+            cnxn, list(issue.derived_cc_ids)))
+    users_by_id.update(framework_views.MakeAllUserViews(
+        cnxn, self.services.user, transitive_owners, der_transitive_owners,
+        direct_comp, trans_comp, transitive_ccs, der_transitive_ccs))
+
+    # Notify interested people according to the reason for their interest:
+    # owners, component auto-cc'd users, cc'd users, starrers, and
+    # other notification addresses.
+    reporter_addr_perm_list = notify_helpers.ComputeIssueChangeAddressPermList(
+        cnxn, reporter, project, issue, self.services, omit_addrs, users_by_id)
+    owner_addr_perm_list = notify_helpers.ComputeIssueChangeAddressPermList(
+        cnxn, direct_owners + transitive_owners, project, issue,
+        self.services, omit_addrs, users_by_id)
+    old_owner_addr_perm_list = notify_helpers.ComputeIssueChangeAddressPermList(
+        cnxn, old_direct_owners + old_transitive_owners, project, issue,
+        self.services, omit_addrs, users_by_id)
+    owner_addr_perm_set = set(owner_addr_perm_list)
+    old_owner_addr_perm_list = [ap for ap in old_owner_addr_perm_list
+                                if ap not in owner_addr_perm_set]
+    der_owner_addr_perm_list = notify_helpers.ComputeIssueChangeAddressPermList(
+        cnxn, der_direct_owners + der_transitive_owners, project, issue,
+        self.services, omit_addrs, users_by_id)
+    cc_addr_perm_list = notify_helpers.ComputeIssueChangeAddressPermList(
+        cnxn, direct_ccs + transitive_ccs, project, issue,
+        self.services, omit_addrs, users_by_id)
+    der_cc_addr_perm_list = notify_helpers.ComputeIssueChangeAddressPermList(
+        cnxn, der_direct_ccs + der_transitive_ccs, project, issue,
+        self.services, omit_addrs, users_by_id)
+
+    starrer_addr_perm_list = []
+    sub_addr_perm_list = []
+    if not noisy or commenter_in_project:
+      # Avoid an OOM by only notifying a number of starrers that we can handle.
+      # And, we really should limit the number of emails that we send anyway.
+      max_starrers = settings.max_starrers_to_notify
+      starrer_ids = starrer_ids[-max_starrers:]
+      # Note: starrers can never be user groups.
+      starrer_addr_perm_list = (
+          notify_helpers.ComputeIssueChangeAddressPermList(
+              cnxn, starrer_ids, project, issue,
+              self.services, omit_addrs, users_by_id,
+              pref_check_function=lambda u: u.notify_starred_issue_change))
+
+      sub_addr_perm_list = _GetSubscribersAddrPermList(
+          cnxn, self.services, issue, project, config, omit_addrs,
+          users_by_id)
+
+    # Get the list of addresses to notify based on filter rules.
+    issue_notify_addr_list = notify_helpers.ComputeIssueNotificationAddrList(
+        issue, omit_addrs)
+    # Get the list of addresses to notify based on project settings.
+    proj_notify_addr_list = notify_helpers.ComputeProjectNotificationAddrList(
+        project, contributor_could_view, omit_addrs)
+
+    # Give each user a bullet-list of all the reasons that apply for that user.
+    group_reason_list = [
+        (reporter_addr_perm_list, 'You reported this issue'),
+        (owner_addr_perm_list, 'You are the owner of the issue'),
+        (old_owner_addr_perm_list,
+         'You were the issue owner before this change'),
+        (der_owner_addr_perm_list, 'A rule made you owner of the issue'),
+        (cc_addr_perm_list, 'You were specifically CC\'d on the issue'),
+        (der_cc_addr_perm_list, 'A rule CC\'d you on the issue'),
+        ]
+    group_reason_list.extend(notify_helpers.ComputeComponentFieldAddrPerms(
+        cnxn, config, issue, project, self.services, omit_addrs,
+        users_by_id))
+    group_reason_list.extend(notify_helpers.ComputeCustomFieldAddrPerms(
+        cnxn, config, issue, project, self.services, omit_addrs,
+        users_by_id))
+    group_reason_list.extend([
+        (starrer_addr_perm_list, 'You starred the issue'),
+        (sub_addr_perm_list, 'Your saved query matched the issue'),
+        (issue_notify_addr_list,
+         'A rule was set up to notify you'),
+        (proj_notify_addr_list,
+         'The project was configured to send all issue notifications '
+         'to this address'),
+        ])
+    commenter_view = users_by_id[comment.user_id]
+    detail_url = framework_helpers.FormatAbsoluteURLForDomain(
+        hostport, issue.project_name, urls.ISSUE_DETAIL,
+        id=issue.local_id)
+    email_tasks = notify_helpers.MakeBulletedEmailWorkItems(
+        group_reason_list, subject, body_for_non_members, body_for_members,
+        project, hostport, commenter_view, seq_num=comment.sequence,
+        detail_url=detail_url)
+
+    return email_tasks
+
+
+class NotifyBlockingChangeTask(NotifyTaskBase):
+  """JSON servlet that notifies appropriate users after a blocking change."""
+
+  _EMAIL_TEMPLATE = 'tracker/issue-blocking-change-notification-email.ezt'
+
+  def HandleRequest(self, mr):
+    """Process the task to notify users after an issue blocking change.
+
+    Args:
+      mr: common information parsed from the HTTP request.
+
+    Returns:
+      Results dictionary in JSON format which is useful just for debugging.
+      The main goal is the side-effect of sending emails.
+    """
+    project_id = mr.specified_project_id
+    if project_id is None:
+      return {
+          'params': {},
+          'notified': [],
+          'message': 'Cannot proceed without a valid project ID.',
+      }
+    commenter_id = mr.GetPositiveIntParam('commenter_id')
+    omit_ids = [commenter_id]
+    hostport = mr.GetParam('hostport')
+    delta_blocker_iids = mr.GetIntListParam('delta_blocker_iids')
+    send_email = bool(mr.GetIntParam('send_email'))
+    params = dict(
+        project_id=project_id, local_id=mr.local_id, commenter_id=commenter_id,
+        hostport=hostport, delta_blocker_iids=delta_blocker_iids,
+        omit_ids=omit_ids, send_email=send_email)
+
+    logging.info('blocking change params are %r', params)
+    issue = self.services.issue.GetIssueByLocalID(
+        mr.cnxn, project_id, mr.local_id)
+    if issue.is_spam:
+      return {
+        'params': params,
+        'notified': [],
+        }
+
+    upstream_issues = self.services.issue.GetIssues(
+        mr.cnxn, delta_blocker_iids)
+    logging.info('updating ids %r', [up.local_id for up in upstream_issues])
+    upstream_projects = tracker_helpers.GetAllIssueProjects(
+        mr.cnxn, upstream_issues, self.services.project)
+    upstream_configs = self.services.config.GetProjectConfigs(
+        mr.cnxn, upstream_projects.keys())
+
+    users_by_id = framework_views.MakeAllUserViews(
+        mr.cnxn, self.services.user, [commenter_id])
+    commenter_view = users_by_id[commenter_id]
+
+    tasks = []
+    if send_email:
+      for upstream_issue in upstream_issues:
+        one_issue_email_tasks = self._ProcessUpstreamIssue(
+            mr.cnxn, upstream_issue,
+            upstream_projects[upstream_issue.project_id],
+            upstream_configs[upstream_issue.project_id],
+            issue, omit_ids, hostport, commenter_view)
+        tasks.extend(one_issue_email_tasks)
+
+    notified = AddAllEmailTasks(tasks)
+
+    return {
+        'params': params,
+        'notified': notified,
+        }
+
+  def _ProcessUpstreamIssue(
+      self, cnxn, upstream_issue, upstream_project, upstream_config,
+      issue, omit_ids, hostport, commenter_view):
+    """Compute notifications for one upstream issue that is now blocking."""
+    upstream_detail_url = framework_helpers.FormatAbsoluteURLForDomain(
+        hostport, upstream_issue.project_name, urls.ISSUE_DETAIL,
+        id=upstream_issue.local_id)
+    logging.info('upstream_detail_url = %r', upstream_detail_url)
+    detail_url = framework_helpers.FormatAbsoluteURLForDomain(
+        hostport, issue.project_name, urls.ISSUE_DETAIL,
+        id=issue.local_id)
+
+    # Only issues that any contributor could view are sent to mailing lists.
+    contributor_could_view = permissions.CanViewIssue(
+        set(), permissions.CONTRIBUTOR_ACTIVE_PERMISSIONSET,
+        upstream_project, upstream_issue)
+
+    # Now construct the e-mail to send
+
+    # Note: we purposely do not notify users who starred an issue
+    # about changes in blocking.
+    users_by_id = framework_views.MakeAllUserViews(
+        cnxn, self.services.user,
+        tracker_bizobj.UsersInvolvedInIssues([upstream_issue]), omit_ids)
+
+    is_blocking = upstream_issue.issue_id in issue.blocked_on_iids
+
+    email_data = {
+        'issue': tracker_views.IssueView(
+            upstream_issue, users_by_id, upstream_config),
+        'summary': upstream_issue.summary,
+        'detail_url': upstream_detail_url,
+        'is_blocking': ezt.boolean(is_blocking),
+        'downstream_issue_ref': tracker_bizobj.FormatIssueRef(
+            (None, issue.local_id)),
+        'downstream_issue_url': detail_url,
+        }
+
+    # TODO(jrobbins): Generate two versions of email body: members
+    # vesion has other member full email addresses exposed.  But, don't
+    # expose too many as we iterate through upstream projects.
+    body = self.email_template.GetResponse(email_data)
+
+    # Just use "Re:", not Message-Id and References because a blocking
+    # notification is not a comment on the issue.
+    subject = 'Re: Issue %d in %s: %s' % (
+        upstream_issue.local_id, upstream_issue.project_name,
+        upstream_issue.summary)
+
+    omit_addrs = {users_by_id[omit_id].email for omit_id in omit_ids}
+
+    # Get the transitive set of owners and Cc'd users, and their UserView's.
+    direct_owners, trans_owners = self.services.usergroup.ExpandAnyUserGroups(
+        cnxn, [tracker_bizobj.GetOwnerId(upstream_issue)])
+    direct_ccs, trans_ccs = self.services.usergroup.ExpandAnyUserGroups(
+        cnxn, list(upstream_issue.cc_ids))
+    # TODO(jrobbins): This will say that the user was cc'd by a rule when it
+    # was really added to the derived_cc_ids by a component.
+    der_direct_ccs, der_transitive_ccs = (
+        self.services.usergroup.ExpandAnyUserGroups(
+            cnxn, list(upstream_issue.derived_cc_ids)))
+    # direct owners and Ccs are already in users_by_id
+    users_by_id.update(framework_views.MakeAllUserViews(
+        cnxn, self.services.user, trans_owners, trans_ccs, der_transitive_ccs))
+
+    owner_addr_perm_list = notify_helpers.ComputeIssueChangeAddressPermList(
+        cnxn, direct_owners + trans_owners, upstream_project, upstream_issue,
+        self.services, omit_addrs, users_by_id)
+    cc_addr_perm_list = notify_helpers.ComputeIssueChangeAddressPermList(
+        cnxn, direct_ccs + trans_ccs, upstream_project, upstream_issue,
+        self.services, omit_addrs, users_by_id)
+    der_cc_addr_perm_list = notify_helpers.ComputeIssueChangeAddressPermList(
+        cnxn, der_direct_ccs + der_transitive_ccs, upstream_project,
+        upstream_issue, self.services, omit_addrs, users_by_id)
+    sub_addr_perm_list = _GetSubscribersAddrPermList(
+        cnxn, self.services, upstream_issue, upstream_project, upstream_config,
+        omit_addrs, users_by_id)
+
+    issue_notify_addr_list = notify_helpers.ComputeIssueNotificationAddrList(
+        upstream_issue, omit_addrs)
+    proj_notify_addr_list = notify_helpers.ComputeProjectNotificationAddrList(
+        upstream_project, contributor_could_view, omit_addrs)
+
+    # Give each user a bullet-list of all the reasons that apply for that user.
+    group_reason_list = [
+        (owner_addr_perm_list, 'You are the owner of the issue'),
+        (cc_addr_perm_list, 'You were specifically CC\'d on the issue'),
+        (der_cc_addr_perm_list, 'A rule CC\'d you on the issue'),
+        ]
+    group_reason_list.extend(notify_helpers.ComputeComponentFieldAddrPerms(
+        cnxn, upstream_config, upstream_issue, upstream_project, self.services,
+        omit_addrs, users_by_id))
+    group_reason_list.extend(notify_helpers.ComputeCustomFieldAddrPerms(
+        cnxn, upstream_config, upstream_issue, upstream_project, self.services,
+        omit_addrs, users_by_id))
+    group_reason_list.extend([
+        # Starrers are not notified of blocking changes to reduce noise.
+        (sub_addr_perm_list, 'Your saved query matched the issue'),
+        (issue_notify_addr_list,
+         'Project filter rules were setup to notify you'),
+        (proj_notify_addr_list,
+         'The project was configured to send all issue notifications '
+         'to this address'),
+        ])
+
+    one_issue_email_tasks = notify_helpers.MakeBulletedEmailWorkItems(
+        group_reason_list, subject, body, body, upstream_project, hostport,
+        commenter_view, detail_url=detail_url)
+
+    return one_issue_email_tasks
+
+
+class NotifyBulkChangeTask(NotifyTaskBase):
+  """JSON servlet that notifies appropriate users after a bulk edit."""
+
+  _EMAIL_TEMPLATE = 'tracker/issue-bulk-change-notification-email.ezt'
+
+  def HandleRequest(self, mr):
+    """Process the task to notify users after an issue blocking change.
+
+    Args:
+      mr: common information parsed from the HTTP request.
+
+    Returns:
+      Results dictionary in JSON format which is useful just for debugging.
+      The main goal is the side-effect of sending emails.
+    """
+    hostport = mr.GetParam('hostport')
+    project_id = mr.specified_project_id
+    if project_id is None:
+      return {
+          'params': {},
+          'notified': [],
+          'message': 'Cannot proceed without a valid project ID.',
+      }
+
+    local_ids = mr.local_id_list
+    old_owner_ids = mr.GetIntListParam('old_owner_ids')
+    comment_text = mr.GetParam('comment_text')
+    commenter_id = mr.GetPositiveIntParam('commenter_id')
+    amendments = mr.GetParam('amendments')
+    send_email = bool(mr.GetIntParam('send_email'))
+    params = dict(
+        project_id=project_id, local_ids=mr.local_id_list,
+        commenter_id=commenter_id, hostport=hostport,
+        old_owner_ids=old_owner_ids, comment_text=comment_text,
+        send_email=send_email, amendments=amendments)
+
+    logging.info('bulk edit params are %r', params)
+    # TODO(jrobbins): For cross-project bulk edits, prefetch all relevant
+    # projects and configs and pass a dict of them to subroutines.
+    project = self.services.project.GetProject(mr.cnxn, project_id)
+    config = self.services.config.GetProjectConfig(mr.cnxn, project_id)
+    issues = self.services.issue.GetIssuesByLocalIDs(
+        mr.cnxn, project_id, local_ids)
+    issues = [issue for issue in issues if not issue.is_spam]
+    anon_perms = permissions.GetPermissions(None, set(), project)
+
+    users_by_id = framework_views.MakeAllUserViews(
+        mr.cnxn, self.services.user, [commenter_id])
+    ids_in_issues = {}
+    starrers = {}
+
+    non_private_issues = []
+    for issue, old_owner_id in zip(issues, old_owner_ids):
+      # TODO(jrobbins): use issue_id consistently rather than local_id.
+      starrers[issue.local_id] = self.services.issue_star.LookupItemStarrers(
+          mr.cnxn, issue.issue_id)
+      named_ids = set()  # users named in user-value fields that notify.
+      for fd in config.field_defs:
+        named_ids.update(notify_helpers.ComputeNamedUserIDsToNotify(issue, fd))
+      direct, indirect = self.services.usergroup.ExpandAnyUserGroups(
+          mr.cnxn, list(issue.cc_ids) + list(issue.derived_cc_ids) +
+          [issue.owner_id, old_owner_id, issue.derived_owner_id] +
+          list(named_ids))
+      ids_in_issues[issue.local_id] = set(starrers[issue.local_id])
+      ids_in_issues[issue.local_id].update(direct)
+      ids_in_issues[issue.local_id].update(indirect)
+      ids_in_issue_needing_views = (
+          ids_in_issues[issue.local_id] |
+          tracker_bizobj.UsersInvolvedInIssues([issue]))
+      new_ids_in_issue = [user_id for user_id in ids_in_issue_needing_views
+                          if user_id not in users_by_id]
+      users_by_id.update(
+          framework_views.MakeAllUserViews(
+              mr.cnxn, self.services.user, new_ids_in_issue))
+
+      anon_can_view = permissions.CanViewIssue(
+          set(), anon_perms, project, issue)
+      if anon_can_view:
+        non_private_issues.append(issue)
+
+    commenter_view = users_by_id[commenter_id]
+    omit_addrs = {commenter_view.email}
+
+    tasks = []
+    if send_email:
+      email_tasks = self._BulkEditEmailTasks(
+          mr.cnxn, issues, old_owner_ids, omit_addrs, project,
+          non_private_issues, users_by_id, ids_in_issues, starrers,
+          commenter_view, hostport, comment_text, amendments, config)
+      tasks = email_tasks
+
+    notified = AddAllEmailTasks(tasks)
+    return {
+        'params': params,
+        'notified': notified,
+        }
+
+  def _BulkEditEmailTasks(
+      self, cnxn, issues, old_owner_ids, omit_addrs, project,
+      non_private_issues, users_by_id, ids_in_issues, starrers,
+      commenter_view, hostport, comment_text, amendments, config):
+    """Generate Email PBs to notify interested users after a bulk edit."""
+    # 1. Get the user IDs of everyone who could be notified,
+    # and make all their user proxies. Also, build a dictionary
+    # of all the users to notify and the issues that they are
+    # interested in.  Also, build a dictionary of additional email
+    # addresses to notify and the issues to notify them of.
+    users_by_id = {}
+    ids_to_notify_of_issue = {}
+    additional_addrs_to_notify_of_issue = collections.defaultdict(list)
+
+    users_to_queries = notify_helpers.GetNonOmittedSubscriptions(
+        cnxn, self.services, [project.project_id], {})
+    config = self.services.config.GetProjectConfig(
+        cnxn, project.project_id)
+    for issue, old_owner_id in zip(issues, old_owner_ids):
+      issue_participants = set(
+          [tracker_bizobj.GetOwnerId(issue), old_owner_id] +
+          tracker_bizobj.GetCcIds(issue))
+      # users named in user-value fields that notify.
+      for fd in config.field_defs:
+        issue_participants.update(
+            notify_helpers.ComputeNamedUserIDsToNotify(issue, fd))
+      for user_id in ids_in_issues[issue.local_id]:
+        # TODO(jrobbins): implement batch GetUser() for speed.
+        if not user_id:
+          continue
+        auth = monorailrequest.AuthData.FromUserID(
+            cnxn, user_id, self.services)
+        if (auth.user_pb.notify_issue_change and
+            not auth.effective_ids.isdisjoint(issue_participants)):
+          ids_to_notify_of_issue.setdefault(user_id, []).append(issue)
+        elif (auth.user_pb.notify_starred_issue_change and
+              user_id in starrers[issue.local_id]):
+          # Skip users who have starred issues that they can no longer view.
+          starrer_perms = permissions.GetPermissions(
+              auth.user_pb, auth.effective_ids, project)
+          granted_perms = tracker_bizobj.GetGrantedPerms(
+              issue, auth.effective_ids, config)
+          starrer_can_view = permissions.CanViewIssue(
+              auth.effective_ids, starrer_perms, project, issue,
+              granted_perms=granted_perms)
+          if starrer_can_view:
+            ids_to_notify_of_issue.setdefault(user_id, []).append(issue)
+        logging.info(
+            'ids_to_notify_of_issue[%s] = %s',
+            user_id,
+            [i.local_id for i in ids_to_notify_of_issue.get(user_id, [])])
+
+      # Find all subscribers that should be notified.
+      subscribers_to_consider = notify_helpers.EvaluateSubscriptions(
+          cnxn, issue, users_to_queries, self.services, config)
+      for sub_id in subscribers_to_consider:
+        auth = monorailrequest.AuthData.FromUserID(cnxn, sub_id, self.services)
+        sub_perms = permissions.GetPermissions(
+            auth.user_pb, auth.effective_ids, project)
+        granted_perms = tracker_bizobj.GetGrantedPerms(
+            issue, auth.effective_ids, config)
+        sub_can_view = permissions.CanViewIssue(
+            auth.effective_ids, sub_perms, project, issue,
+            granted_perms=granted_perms)
+        if sub_can_view:
+          ids_to_notify_of_issue.setdefault(sub_id, []).append(issue)
+
+      if issue in non_private_issues:
+        for notify_addr in issue.derived_notify_addrs:
+          additional_addrs_to_notify_of_issue[notify_addr].append(issue)
+
+    # 2. Compose an email specifically for each user.
+    email_tasks = []
+    needed_user_view_ids = [uid for uid in ids_to_notify_of_issue
+                            if uid not in users_by_id]
+    users_by_id.update(framework_views.MakeAllUserViews(
+        cnxn, self.services.user, needed_user_view_ids))
+    for user_id in ids_to_notify_of_issue:
+      if not user_id:
+        continue  # Don't try to notify NO_USER_SPECIFIED
+      if users_by_id[user_id].email in omit_addrs:
+        logging.info('Omitting %s', user_id)
+        continue
+      user_issues = ids_to_notify_of_issue[user_id]
+      if not user_issues:
+        continue  # user's prefs indicate they don't want these notifications
+      email = self._FormatBulkIssuesEmail(
+          users_by_id[user_id].email, user_issues, users_by_id,
+          commenter_view, hostport, comment_text, amendments, config, project)
+      email_tasks.append(email)
+      omit_addrs.add(users_by_id[user_id].email)
+      logging.info('about to bulk notify %s (%s) of %s',
+                   users_by_id[user_id].email, user_id,
+                   [issue.local_id for issue in user_issues])
+
+    # 3. Compose one email to each notify_addr with all the issues that it
+    # is supossed to be notified about.
+    for addr, addr_issues in additional_addrs_to_notify_of_issue.iteritems():
+      email = self._FormatBulkIssuesEmail(
+          addr, addr_issues, users_by_id, commenter_view, hostport,
+          comment_text, amendments, config, project)
+      email_tasks.append(email)
+      omit_addrs.add(addr)
+      logging.info('about to bulk notify additional addr %s of %s',
+                   addr, [addr_issue.local_id for addr_issue in addr_issues])
+
+    # 4. Add in the project's issue_notify_address.  This happens even if it
+    # is the same as the commenter's email address (which would be an unusual
+    # but valid project configuration).  Only issues that any contributor could
+    # view are included in emails to the all-issue-activity mailing lists.
+    if (project.issue_notify_address
+        and project.issue_notify_address not in omit_addrs):
+      non_private_issues_live = []
+      for issue in issues:
+        contributor_could_view = permissions.CanViewIssue(
+            set(), permissions.CONTRIBUTOR_ACTIVE_PERMISSIONSET,
+            project, issue)
+        if contributor_could_view:
+          non_private_issues_live.append(issue)
+
+      if non_private_issues_live:
+        email = self._FormatBulkIssuesEmail(
+            project.issue_notify_address, non_private_issues_live,
+            users_by_id, commenter_view, hostport, comment_text, amendments,
+            config, project)
+        email_tasks.append(email)
+        omit_addrs.add(project.issue_notify_address)
+        logging.info('about to bulk notify all-issues %s of %s',
+                     project.issue_notify_address,
+                     [issue.local_id for issue in non_private_issues])
+
+    return email_tasks
+
+  def _FormatBulkIssuesEmail(
+      self, dest_email, issues, users_by_id, commenter_view,
+      hostport, comment_text, amendments, config, _project):
+    """Format an email to one user listing many issues."""
+    # TODO(jrobbins): Generate two versions of email body: members
+    # vesion has full email addresses exposed.  And, use the full
+    # commenter email address in the From: line when sending to
+    # a member.
+    subject, body = self._FormatBulkIssues(
+        issues, users_by_id, commenter_view, hostport, comment_text,
+        amendments, config)
+
+    from_addr = emailfmt.NoReplyAddress(commenter_view=commenter_view)
+    return dict(from_addr=from_addr, to=dest_email, subject=subject, body=body)
+
+  def _FormatBulkIssues(
+      self, issues, users_by_id, commenter_view, hostport, comment_text,
+      amendments, config, body_type='email'):
+    """Format a subject and body for a bulk issue edit."""
+    assert body_type in ('email', 'feed')
+    project_name = issues[0].project_name
+
+    issue_views = []
+    for issue in issues:
+      # TODO(jrobbins): choose config from dict of prefetched configs.
+      issue_views.append(tracker_views.IssueView(issue, users_by_id, config))
+
+    email_data = {
+        'hostport': hostport,
+        'num_issues': len(issues),
+        'issues': issue_views,
+        'comment_text': comment_text,
+        'commenter': commenter_view,
+        'amendments': amendments,
+        'body_type': body_type,
+    }
+
+    if len(issues) == 1:
+      subject = 'issue %s in %s: %s' % (
+          issues[0].local_id, project_name, issues[0].summary)
+      # TODO(jrobbins): Look up the sequence number instead and treat this
+      # more like an individual change for email threading.  For now, just
+      # add "Re:" because bulk edits are always replies.
+      subject = 'Re: ' + subject
+    else:
+      subject = '%d issues changed in %s' % (len(issues), project_name)
+
+    body = self.email_template.GetResponse(email_data)
+
+    return subject, body
+
+
+class OutboundEmailTask(jsonfeed.InternalTask):
+  """JSON servlet that sends one email."""
+
+  def HandleRequest(self, mr):
+    """Process the task to send one email message.
+
+    Args:
+      mr: common information parsed from the HTTP request.
+
+    Returns:
+      Results dictionary in JSON format which is useful just for debugging.
+      The main goal is the side-effect of sending emails.
+    """
+    # If running on a GAFYD domain, you must define an app alias on the
+    # Application Settings admin web page.
+    sender = mr.GetParam('from_addr')
+    reply_to = mr.GetParam('reply_to')
+    to = mr.GetParam('to')
+    if not to:
+      # Cannot proceed if we cannot create a valid EmailMessage.
+      return
+    references = mr.GetParam('references')
+    subject = mr.GetParam('subject')
+    body = mr.GetParam('body')
+    html_body = mr.GetParam('html_body')
+
+    if settings.dev_mode:
+      to_format = settings.send_dev_email_to
+    else:
+      to_format = settings.send_all_email_to
+
+    if to_format:
+      to_user, to_domain = to.split('@')
+      to = to_format % {'user': to_user, 'domain': to_domain}
+
+    logging.info(
+        'Email:\n sender: %s\n reply_to: %s\n to: %s\n references: %s\n '
+        'subject: %s\n body: %s\n html body: %s',
+        sender, reply_to, to, references, subject, body, html_body)
+    message = mail.EmailMessage(
+        sender=sender, to=to, subject=subject, body=body)
+    if html_body:
+      message.html = html_body
+    if reply_to:
+      message.reply_to = reply_to
+    if references:
+      message.headers = {'References': references}
+    if settings.unit_test_mode:
+      logging.info('Sending message "%s" in test mode.', message.subject)
+    else:
+      message.send()
+
+    return dict(
+        sender=sender, to=to, subject=subject, body=body, html_body=html_body,
+        reply_to=reply_to, references=references)
+
+
+def _GetSubscribersAddrPermList(
+    cnxn, services, issue, project, config, omit_addrs, users_by_id):
+  """Lookup subscribers, evaluate their saved queries, and decide to notify."""
+  users_to_queries = notify_helpers.GetNonOmittedSubscriptions(
+      cnxn, services, [project.project_id], omit_addrs)
+  # TODO(jrobbins): need to pass through the user_id to use for "me".
+  subscribers_to_notify = notify_helpers.EvaluateSubscriptions(
+      cnxn, issue, users_to_queries, services, config)
+  # TODO(jrobbins): expand any subscribers that are user groups.
+  subs_needing_user_views = [
+      uid for uid in subscribers_to_notify if uid not in users_by_id]
+  users_by_id.update(framework_views.MakeAllUserViews(
+      cnxn, services.user, subs_needing_user_views))
+  sub_addr_perm_list = notify_helpers.ComputeIssueChangeAddressPermList(
+      cnxn, subscribers_to_notify, project, issue, services, omit_addrs,
+      users_by_id, pref_check_function=lambda *args: True)
+
+  return sub_addr_perm_list