Add a Herald action to trigger "Must Encrypt" for mail

Summary: Depends on D18983. Ref T13053. Adds a new Herald action to activate the "must encrypt" flag and drop mail content.

Test Plan:
- Created a new Herald rule:

{F5407075}

- Created a "dog task" (woof woof, unsecure) and a "duck task" (quack quack, secure).
- Viewed mail for both in `bin/mail` and web UI, saw appropriate security/encryption behavior.
- Viewed "Must Encrypt" in "Headers" tab for the duck mail, saw why the mail was encrypted (link to Herald rule).

Reviewers: amckinley

Reviewed By: amckinley

Maniphest Tasks: T13053

Differential Revision: https://secure.phabricator.com/D18984

src/__phutil_library_map__.php

···
     'PhabricatorMailManagementUnverifyWorkflow' => 'applications/metamta/management/PhabricatorMailManagementUnverifyWorkflow.php',
     'PhabricatorMailManagementVolumeWorkflow' => 'applications/metamta/management/PhabricatorMailManagementVolumeWorkflow.php',
     'PhabricatorMailManagementWorkflow' => 'applications/metamta/management/PhabricatorMailManagementWorkflow.php',
+    'PhabricatorMailMustEncryptHeraldAction' => 'applications/metamta/herald/PhabricatorMailMustEncryptHeraldAction.php',
     'PhabricatorMailOutboundMailHeraldAdapter' => 'applications/metamta/herald/PhabricatorMailOutboundMailHeraldAdapter.php',
     'PhabricatorMailOutboundRoutingHeraldAction' => 'applications/metamta/herald/PhabricatorMailOutboundRoutingHeraldAction.php',
     'PhabricatorMailOutboundRoutingSelfEmailHeraldAction' => 'applications/metamta/herald/PhabricatorMailOutboundRoutingSelfEmailHeraldAction.php',
···
     'PhabricatorMailManagementUnverifyWorkflow' => 'PhabricatorMailManagementWorkflow',
     'PhabricatorMailManagementVolumeWorkflow' => 'PhabricatorMailManagementWorkflow',
     'PhabricatorMailManagementWorkflow' => 'PhabricatorManagementWorkflow',
+    'PhabricatorMailMustEncryptHeraldAction' => 'HeraldAction',
     'PhabricatorMailOutboundMailHeraldAdapter' => 'HeraldAdapter',
     'PhabricatorMailOutboundRoutingHeraldAction' => 'HeraldAction',
     'PhabricatorMailOutboundRoutingSelfEmailHeraldAction' => 'PhabricatorMailOutboundRoutingHeraldAction',

src/applications/herald/adapter/HeraldAdapter.php

···
   private $edgeCache = array();
   private $forbiddenActions = array();
   private $viewer;
+  private $mustEncryptReasons = array();
 
   public function getEmailPHIDs() {
     return array_values($this->emailPHIDs);
···
     }
 
     return $this->forbiddenActions[$action];
+  }
+
+
+/* -(  Must Encrypt  )------------------------------------------------------- */
+
+
+  final public function addMustEncryptReason($reason) {
+    $this->mustEncryptReasons[] = $reason;
+    return $this;
+  }
+
+  final public function getMustEncryptReasons() {
+    return $this->mustEncryptReasons;
   }
 
 }

src/applications/metamta/controller/PhabricatorMetaMTAMailViewController.php

···
       $properties->addProperty($key, $value);
     }
 
+    $encrypt_phids = $mail->getMustEncryptReasons();
+    if ($encrypt_phids) {
+      $properties->addProperty(
+        pht('Must Encrypt'),
+        $viewer->loadHandles($encrypt_phids)
+          ->renderList());
+    }
+
+
     return $properties;
   }
 

src/applications/metamta/herald/PhabricatorMailMustEncryptHeraldAction.php

···
+<?php
+
+final class PhabricatorMailMustEncryptHeraldAction
+  extends HeraldAction {
+
+  const DO_MUST_ENCRYPT = 'do.must-encrypt';
+
+  const ACTIONCONST = 'email.must-encrypt';
+
+  public function getHeraldActionName() {
+    return pht('Require secure email');
+  }
+
+  public function renderActionDescription($value) {
+    return pht(
+      'Require mail content be transmitted only over secure channels.');
+  }
+  public function supportsObject($object) {
+    return self::isMailGeneratingObject($object);
+  }
+
+  public function getActionGroupKey() {
+    return HeraldUtilityActionGroup::ACTIONGROUPKEY;
+  }
+
+  public function supportsRuleType($rule_type) {
+    return ($rule_type != HeraldRuleTypeConfig::RULE_TYPE_PERSONAL);
+  }
+
+  public function getHeraldActionStandardType() {
+    return self::STANDARD_NONE;
+  }
+
+  public function applyEffect($object, HeraldEffect $effect) {
+    $rule_phid = $effect->getRule()->getPHID();
+
+    $adapter = $this->getAdapter();
+    $adapter->addMustEncryptReason($rule_phid);
+
+    $this->logEffect(self::DO_MUST_ENCRYPT, array($rule_phid));
+  }
+
+  protected function getActionEffectMap() {
+    return array(
+      self::DO_MUST_ENCRYPT => array(
+        'icon' => 'fa-shield',
+        'color' => 'blue',
+        'name' => pht('Must Encrypt'),
+      ),
+    );
+  }
+
+  protected function renderActionEffectDescription($type, $data) {
+    switch ($type) {
+      case self::DO_MUST_ENCRYPT:
+        return pht(
+          'Made it a requirement that mail content be transmitted only '.
+          'over secure channels.');
+    }
+  }
+
+}

src/applications/metamta/herald/PhabricatorMetaMTAEmailHeraldAction.php

···
   }
 
   public function supportsObject($object) {
+    return self::isMailGeneratingObject($object);
+  }
+
+  public static function isMailGeneratingObject($object) {
     // NOTE: This implementation lacks generality, but there's no great way to
     // figure out if something generates email right now.
 

src/applications/metamta/storage/PhabricatorMetaMTAMail.php

···
     return $this->getParam('mustEncrypt', false);
   }
 
+  public function setMustEncryptReasons(array $reasons) {
+    $this->setParam('mustEncryptReasons', $reasons);
+    return $this;
+  }
+
+  public function getMustEncryptReasons() {
+    return $this->getParam('mustEncryptReasons', array());
+  }
+
   public function setHTMLBody($html) {
     $this->setParam('html-body', $html);
     return $this;

src/applications/transactions/editor/PhabricatorApplicationTransactionEditor.php

···
   private $mailShouldSend = false;
   private $modularTypes;
   private $silent;
+  private $mustEncrypt;
 
   private $transactionQueue = array();
 
···
         $this->loadHandles($xactions);
 
         $mail = $this->buildMailForTarget($object, $xactions, $target);
+
+        if ($this->mustEncrypt) {
+          $mail
+            ->setMustEncrypt(true)
+            ->setMustEncryptReasons($this->mustEncrypt);
+        }
+
       } catch (Exception $ex) {
         $caught = $ex;
       }
···
         $adapter->getQueuedHarbormasterBuildRequests());
     }
 
+    $this->mustEncrypt = $adapter->getMustEncryptReasons();
+
     return array_merge(
       $this->didApplyHeraldRules($object, $adapter, $xscript),
       $adapter->getQueuedTransactions());
···
       'feedRelatedPHIDs',
       'feedShouldPublish',
       'mailShouldSend',
+      'mustEncrypt',
     );
   }