No OneTemporary
Actions

Size

88 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/herald/adapter/HeraldAdapter.php b/src/applications/herald/adapter/HeraldAdapter.php
	index bafad0d440..d67c69f584 100644
	--- a/src/applications/herald/adapter/HeraldAdapter.php
	+++ b/src/applications/herald/adapter/HeraldAdapter.php
	@@ -1,1161 +1,1165 @@
	<?php

	abstract class HeraldAdapter extends Phobject {

	const CONDITION_CONTAINS = 'contains';
	const CONDITION_NOT_CONTAINS = '!contains';
	const CONDITION_IS = 'is';
	const CONDITION_IS_NOT = '!is';
	const CONDITION_IS_ANY = 'isany';
	const CONDITION_IS_NOT_ANY = '!isany';
	const CONDITION_INCLUDE_ALL = 'all';
	const CONDITION_INCLUDE_ANY = 'any';
	const CONDITION_INCLUDE_NONE = 'none';
	const CONDITION_IS_ME = 'me';
	const CONDITION_IS_NOT_ME = '!me';
	const CONDITION_REGEXP = 'regexp';
	const CONDITION_NOT_REGEXP = '!regexp';
	const CONDITION_RULE = 'conditions';
	const CONDITION_NOT_RULE = '!conditions';
	const CONDITION_EXISTS = 'exists';
	const CONDITION_NOT_EXISTS = '!exists';
	const CONDITION_UNCONDITIONALLY = 'unconditionally';
	const CONDITION_NEVER = 'never';
	const CONDITION_REGEXP_PAIR = 'regexp-pair';
	const CONDITION_HAS_BIT = 'bit';
	const CONDITION_NOT_BIT = '!bit';
	const CONDITION_IS_TRUE = 'true';
	const CONDITION_IS_FALSE = 'false';

	private $contentSource;
	private $isNewObject;
	private $applicationEmail;
	private $appliedTransactions = array();
	private $queuedTransactions = array();
	private $emailPHIDs = array();
	private $forcedEmailPHIDs = array();
	private $fieldMap;
	private $actionMap;
	private $edgeCache = array();
	private $forbiddenActions = array();

	public function getEmailPHIDs() {
	return array_values($this->emailPHIDs);
	}

	public function getForcedEmailPHIDs() {
	return array_values($this->forcedEmailPHIDs);
	}

	public function addEmailPHID($phid, $force) {
	$this->emailPHIDs[$phid] = $phid;
	if ($force) {
	$this->forcedEmailPHIDs[$phid] = $phid;
	}
	return $this;
	}

	public function setContentSource(PhabricatorContentSource $content_source) {
	$this->contentSource = $content_source;
	return $this;
	}
	public function getContentSource() {
	return $this->contentSource;
	}

	public function getIsNewObject() {
	if (is_bool($this->isNewObject)) {
	return $this->isNewObject;
	}

	throw new Exception(
	pht(
	'You must %s to a boolean first!',
	'setIsNewObject()'));
	}
	public function setIsNewObject($new) {
	$this->isNewObject = (bool)$new;
	return $this;
	}

	public function supportsApplicationEmail() {
	return false;
	}

	public function setApplicationEmail(
	PhabricatorMetaMTAApplicationEmail $email) {
	$this->applicationEmail = $email;
	return $this;
	}

	public function getApplicationEmail() {
	return $this->applicationEmail;
	}

	public function getPHID() {
	return $this->getObject()->getPHID();
	}

	abstract public function getHeraldName();

	public function getHeraldField($field_key) {
	return $this->requireFieldImplementation($field_key)
	->getHeraldFieldValue($this->getObject());
	}

	public function applyHeraldEffects(array $effects) {
	assert_instances_of($effects, 'HeraldEffect');

	$result = array();
	foreach ($effects as $effect) {
	$result[] = $this->applyStandardEffect($effect);
	}

	return $result;
	}

	public function isAvailableToUser(PhabricatorUser $viewer) {
	$applications = id(new PhabricatorApplicationQuery())
	->setViewer($viewer)
	->withInstalled(true)
	->withClasses(array($this->getAdapterApplicationClass()))
	->execute();

	return !empty($applications);
	}


	/**
	* Set the list of transactions which just took effect.
	*
	* These transactions are set by @{class:PhabricatorApplicationEditor}
	* automatically, before it invokes Herald.
	*
	* @param list<PhabricatorApplicationTransaction> List of transactions.
	* @return this
	*/
	final public function setAppliedTransactions(array $xactions) {
	assert_instances_of($xactions, 'PhabricatorApplicationTransaction');
	$this->appliedTransactions = $xactions;
	return $this;
	}


	/**
	* Get a list of transactions which just took effect.
	*
	* When an object is edited normally, transactions are applied and then
	* Herald executes. You can call this method to examine the transactions
	* if you want to react to them.
	*
	* @return list<PhabricatorApplicationTransaction> List of transactions.
	*/
	final public function getAppliedTransactions() {
	return $this->appliedTransactions;
	}

	public function queueTransaction($transaction) {
	$this->queuedTransactions[] = $transaction;
	}

	public function getQueuedTransactions() {
	return $this->queuedTransactions;
	}

	public function newTransaction() {
	$object = $this->newObject();

	if (!($object instanceof PhabricatorApplicationTransactionInterface)) {
	throw new Exception(
	pht(
	'Unable to build a new transaction for adapter object; it does '.
	'not implement "%s".',
	'PhabricatorApplicationTransactionInterface'));
	}

	return $object->getApplicationTransactionTemplate();
	}


	/**
	* NOTE: You generally should not override this; it exists to support legacy
	* adapters which had hard-coded content types.
	*/
	public function getAdapterContentType() {
	return get_class($this);
	}

	abstract public function getAdapterContentName();
	abstract public function getAdapterContentDescription();
	abstract public function getAdapterApplicationClass();
	abstract public function getObject();

	/**
	* Return a new characteristic object for this adapter.
	*
	* The adapter will use this object to test for interfaces, generate
	* transactions, and interact with custom fields.
	*
	* Adapters must return an object from this method to enable custom
	* field rules and various implicit actions.
	*
	* Normally, you'll return an empty version of the adapted object:
	*
	* return new ApplicationObject();
	*
	* @return null\|object Template object.
	*/
	protected function newObject() {
	return null;
	}

	public function supportsRuleType($rule_type) {
	return false;
	}

	public function canTriggerOnObject($object) {
	return false;
	}

	public function isTestAdapterForObject($object) {
	return false;
	}

	public function canCreateTestAdapterForObject($object) {
	return $this->isTestAdapterForObject($object);
	}

	public function newTestAdapter(PhabricatorUser $viewer, $object) {
	return id(clone $this)
	->setObject($object);
	}

	public function getAdapterTestDescription() {
	return null;
	}

	public function explainValidTriggerObjects() {
	return pht('This adapter can not trigger on objects.');
	}

	public function getTriggerObjectPHIDs() {
	return array($this->getPHID());
	}

	public function getAdapterSortKey() {
	return sprintf(
	'%08d%s',
	$this->getAdapterSortOrder(),
	$this->getAdapterContentName());
	}

	public function getAdapterSortOrder() {
	return 1000;
	}


	/* -( Fields )------------------------------------------------------------- */

	private function getFieldImplementationMap() {
	if ($this->fieldMap === null) {
	// We can't use PhutilClassMapQuery here because field expansion
	// depends on the adapter and object.

	$object = $this->getObject();

	$map = array();
	$all = HeraldField::getAllFields();
	foreach ($all as $key => $field) {
	$field = id(clone $field)->setAdapter($this);

	if (!$field->supportsObject($object)) {
	continue;
	}
	$subfields = $field->getFieldsForObject($object);
	foreach ($subfields as $subkey => $subfield) {
	if (isset($map[$subkey])) {
	throw new Exception(
	pht(
	'Two HeraldFields (of classes "%s" and "%s") have the same '.
	'field key ("%s") after expansion for an object of class '.
	'"%s" inside adapter "%s". Each field must have a unique '.
	'field key.',
	get_class($subfield),
	get_class($map[$subkey]),
	$subkey,
	get_class($object),
	get_class($this)));
	}

	$subfield = id(clone $subfield)->setAdapter($this);

	$map[$subkey] = $subfield;
	}
	}
	$this->fieldMap = $map;
	}

	return $this->fieldMap;
	}

	private function getFieldImplementation($key) {
	return idx($this->getFieldImplementationMap(), $key);
	}

	public function getFields() {
	return array_keys($this->getFieldImplementationMap());
	}

	public function getFieldNameMap() {
	return mpull($this->getFieldImplementationMap(), 'getHeraldFieldName');
	}

	public function getFieldGroupKey($field_key) {
	$field = $this->getFieldImplementation($field_key);

	if (!$field) {
	return null;
	}

	return $field->getFieldGroupKey();
	}


	/* -( Conditions )--------------------------------------------------------- */


	public function getConditionNameMap() {
	return array(
	self::CONDITION_CONTAINS => pht('contains'),
	self::CONDITION_NOT_CONTAINS => pht('does not contain'),
	self::CONDITION_IS => pht('is'),
	self::CONDITION_IS_NOT => pht('is not'),
	self::CONDITION_IS_ANY => pht('is any of'),
	self::CONDITION_IS_TRUE => pht('is true'),
	self::CONDITION_IS_FALSE => pht('is false'),
	self::CONDITION_IS_NOT_ANY => pht('is not any of'),
	self::CONDITION_INCLUDE_ALL => pht('include all of'),
	self::CONDITION_INCLUDE_ANY => pht('include any of'),
	self::CONDITION_INCLUDE_NONE => pht('do not include'),
	self::CONDITION_IS_ME => pht('is myself'),
	self::CONDITION_IS_NOT_ME => pht('is not myself'),
	self::CONDITION_REGEXP => pht('matches regexp'),
	self::CONDITION_NOT_REGEXP => pht('does not match regexp'),
	self::CONDITION_RULE => pht('matches:'),
	self::CONDITION_NOT_RULE => pht('does not match:'),
	self::CONDITION_EXISTS => pht('exists'),
	self::CONDITION_NOT_EXISTS => pht('does not exist'),
	self::CONDITION_UNCONDITIONALLY => '', // don't show anything!
	self::CONDITION_NEVER => '', // don't show anything!
	self::CONDITION_REGEXP_PAIR => pht('matches regexp pair'),
	self::CONDITION_HAS_BIT => pht('has bit'),
	self::CONDITION_NOT_BIT => pht('lacks bit'),
	);
	}

	public function getConditionsForField($field) {
	return $this->requireFieldImplementation($field)
	->getHeraldFieldConditions();
	}

	private function requireFieldImplementation($field_key) {
	$field = $this->getFieldImplementation($field_key);

	if (!$field) {
	throw new Exception(
	pht(
	'No field with key "%s" is available to Herald adapter "%s".',
	$field_key,
	get_class($this)));
	}

	return $field;
	}

	public function doesConditionMatch(
	HeraldEngine $engine,
	HeraldRule $rule,
	HeraldCondition $condition,
	$field_value) {

	$condition_type = $condition->getFieldCondition();
	$condition_value = $condition->getValue();

	switch ($condition_type) {
	case self::CONDITION_CONTAINS:
	case self::CONDITION_NOT_CONTAINS:
	// "Contains and "does not contain" can take an array of strings, as in
	// "Any changed filename" for diffs.

	$result_if_match = ($condition_type == self::CONDITION_CONTAINS);

	foreach ((array)$field_value as $value) {
	if (stripos($value, $condition_value) !== false) {
	return $result_if_match;
	}
	}
	return !$result_if_match;
	case self::CONDITION_IS:
	return ($field_value == $condition_value);
	case self::CONDITION_IS_NOT:
	return ($field_value != $condition_value);
	case self::CONDITION_IS_ME:
	return ($field_value == $rule->getAuthorPHID());
	case self::CONDITION_IS_NOT_ME:
	return ($field_value != $rule->getAuthorPHID());
	case self::CONDITION_IS_ANY:
	if (!is_array($condition_value)) {
	throw new HeraldInvalidConditionException(
	pht('Expected condition value to be an array.'));
	}
	$condition_value = array_fuse($condition_value);
	return isset($condition_value[$field_value]);
	case self::CONDITION_IS_NOT_ANY:
	if (!is_array($condition_value)) {
	throw new HeraldInvalidConditionException(
	pht('Expected condition value to be an array.'));
	}
	$condition_value = array_fuse($condition_value);
	return !isset($condition_value[$field_value]);
	case self::CONDITION_INCLUDE_ALL:
	if (!is_array($field_value)) {
	throw new HeraldInvalidConditionException(
	pht('Object produced non-array value!'));
	}
	if (!is_array($condition_value)) {
	throw new HeraldInvalidConditionException(
	pht('Expected condition value to be an array.'));
	}

	$have = array_select_keys(array_fuse($field_value), $condition_value);
	return (count($have) == count($condition_value));
	case self::CONDITION_INCLUDE_ANY:
	return (bool)array_select_keys(
	array_fuse($field_value),
	$condition_value);
	case self::CONDITION_INCLUDE_NONE:
	return !array_select_keys(
	array_fuse($field_value),
	$condition_value);
	case self::CONDITION_EXISTS:
	case self::CONDITION_IS_TRUE:
	return (bool)$field_value;
	case self::CONDITION_NOT_EXISTS:
	case self::CONDITION_IS_FALSE:
	return !$field_value;
	case self::CONDITION_UNCONDITIONALLY:
	return (bool)$field_value;
	case self::CONDITION_NEVER:
	return false;
	case self::CONDITION_REGEXP:
	case self::CONDITION_NOT_REGEXP:
	$result_if_match = ($condition_type == self::CONDITION_REGEXP);

	foreach ((array)$field_value as $value) {
	// We add the 'S' flag because we use the regexp multiple times.
	// It shouldn't cause any troubles if the flag is already there
	// - /./S is evaluated same as /./SS.
	$result = @preg_match($condition_value.'S', $value);
	if ($result === false) {
	throw new HeraldInvalidConditionException(
	pht('Regular expression is not valid!'));
	}
	if ($result) {
	return $result_if_match;
	}
	}
	return !$result_if_match;
	case self::CONDITION_REGEXP_PAIR:
	// Match a JSON-encoded pair of regular expressions against a
	// dictionary. The first regexp must match the dictionary key, and the
	// second regexp must match the dictionary value. If any key/value pair
	// in the dictionary matches both regexps, the condition is satisfied.
	$regexp_pair = null;
	try {
	$regexp_pair = phutil_json_decode($condition_value);
	} catch (PhutilJSONParserException $ex) {
	throw new HeraldInvalidConditionException(
	pht('Regular expression pair is not valid JSON!'));
	}
	if (count($regexp_pair) != 2) {
	throw new HeraldInvalidConditionException(
	pht('Regular expression pair is not a pair!'));
	}

	$key_regexp = array_shift($regexp_pair);
	$value_regexp = array_shift($regexp_pair);

	foreach ((array)$field_value as $key => $value) {
	$key_matches = @preg_match($key_regexp, $key);
	if ($key_matches === false) {
	throw new HeraldInvalidConditionException(
	pht('First regular expression is invalid!'));
	}
	if ($key_matches) {
	$value_matches = @preg_match($value_regexp, $value);
	if ($value_matches === false) {
	throw new HeraldInvalidConditionException(
	pht('Second regular expression is invalid!'));
	}
	if ($value_matches) {
	return true;
	}
	}
	}
	return false;
	case self::CONDITION_RULE:
	case self::CONDITION_NOT_RULE:
	$rule = $engine->getRule($condition_value);
	if (!$rule) {
	throw new HeraldInvalidConditionException(
	pht('Condition references a rule which does not exist!'));
	}

	$is_not = ($condition_type == self::CONDITION_NOT_RULE);
	$result = $engine->doesRuleMatch($rule, $this);
	if ($is_not) {
	$result = !$result;
	}
	return $result;
	case self::CONDITION_HAS_BIT:
	return (($condition_value & $field_value) === (int)$condition_value);
	case self::CONDITION_NOT_BIT:
	return (($condition_value & $field_value) !== (int)$condition_value);
	default:
	throw new HeraldInvalidConditionException(
	pht("Unknown condition '%s'.", $condition_type));
	}
	}

	public function willSaveCondition(HeraldCondition $condition) {
	$condition_type = $condition->getFieldCondition();
	$condition_value = $condition->getValue();

	switch ($condition_type) {
	case self::CONDITION_REGEXP:
	case self::CONDITION_NOT_REGEXP:
	$ok = @preg_match($condition_value, '');
	if ($ok === false) {
	throw new HeraldInvalidConditionException(
	pht(
	'The regular expression "%s" is not valid. Regular expressions '.
	'must have enclosing characters (e.g. "@/path/to/file@", not '.
	'"/path/to/file") and be syntactically correct.',
	$condition_value));
	}
	break;
	case self::CONDITION_REGEXP_PAIR:
	$json = null;
	try {
	$json = phutil_json_decode($condition_value);
	} catch (PhutilJSONParserException $ex) {
	throw new HeraldInvalidConditionException(
	pht(
	'The regular expression pair "%s" is not valid JSON. Enter a '.
	'valid JSON array with two elements.',
	$condition_value));
	}

	if (count($json) != 2) {
	throw new HeraldInvalidConditionException(
	pht(
	'The regular expression pair "%s" must have exactly two '.
	'elements.',
	$condition_value));
	}

	$key_regexp = array_shift($json);
	$val_regexp = array_shift($json);

	$key_ok = @preg_match($key_regexp, '');
	if ($key_ok === false) {
	throw new HeraldInvalidConditionException(
	pht(
	'The first regexp in the regexp pair, "%s", is not a valid '.
	'regexp.',
	$key_regexp));
	}

	$val_ok = @preg_match($val_regexp, '');
	if ($val_ok === false) {
	throw new HeraldInvalidConditionException(
	pht(
	'The second regexp in the regexp pair, "%s", is not a valid '.
	'regexp.',
	$val_regexp));
	}
	break;
	case self::CONDITION_CONTAINS:
	case self::CONDITION_NOT_CONTAINS:
	case self::CONDITION_IS:
	case self::CONDITION_IS_NOT:
	case self::CONDITION_IS_ANY:
	case self::CONDITION_IS_NOT_ANY:
	case self::CONDITION_INCLUDE_ALL:
	case self::CONDITION_INCLUDE_ANY:
	case self::CONDITION_INCLUDE_NONE:
	case self::CONDITION_IS_ME:
	case self::CONDITION_IS_NOT_ME:
	case self::CONDITION_RULE:
	case self::CONDITION_NOT_RULE:
	case self::CONDITION_EXISTS:
	case self::CONDITION_NOT_EXISTS:
	case self::CONDITION_UNCONDITIONALLY:
	case self::CONDITION_NEVER:
	case self::CONDITION_HAS_BIT:
	case self::CONDITION_NOT_BIT:
	case self::CONDITION_IS_TRUE:
	case self::CONDITION_IS_FALSE:
	// No explicit validation for these types, although there probably
	// should be in some cases.
	break;
	default:
	throw new HeraldInvalidConditionException(
	pht(
	'Unknown condition "%s"!',
	$condition_type));
	}
	}


	/* -( Actions )------------------------------------------------------------ */

	private function getActionImplementationMap() {
	if ($this->actionMap === null) {
	// We can't use PhutilClassMapQuery here because action expansion
	// depends on the adapter and object.

	$object = $this->getObject();

	$map = array();
	$all = HeraldAction::getAllActions();
	foreach ($all as $key => $action) {
	$action = id(clone $action)->setAdapter($this);

	if (!$action->supportsObject($object)) {
	continue;
	}

	$subactions = $action->getActionsForObject($object);
	foreach ($subactions as $subkey => $subaction) {
	if (isset($map[$subkey])) {
	throw new Exception(
	pht(
	'Two HeraldActions (of classes "%s" and "%s") have the same '.
	'action key ("%s") after expansion for an object of class '.
	'"%s" inside adapter "%s". Each action must have a unique '.
	'action key.',
	get_class($subaction),
	get_class($map[$subkey]),
	$subkey,
	get_class($object),
	get_class($this)));
	}

	$subaction = id(clone $subaction)->setAdapter($this);

	$map[$subkey] = $subaction;
	}
	}
	$this->actionMap = $map;
	}

	return $this->actionMap;
	}

	private function requireActionImplementation($action_key) {
	$action = $this->getActionImplementation($action_key);

	if (!$action) {
	throw new Exception(
	pht(
	'No action with key "%s" is available to Herald adapter "%s".',
	$action_key,
	get_class($this)));
	}

	return $action;
	}

	private function getActionsForRuleType($rule_type) {
	$actions = $this->getActionImplementationMap();

	foreach ($actions as $key => $action) {
	if (!$action->supportsRuleType($rule_type)) {
	unset($actions[$key]);
	}
	}

	return $actions;
	}

	public function getActionImplementation($key) {
	return idx($this->getActionImplementationMap(), $key);
	}

	public function getActionKeys() {
	return array_keys($this->getActionImplementationMap());
	}

	public function getActionGroupKey($action_key) {
	$action = $this->getActionImplementation($action_key);
	if (!$action) {
	return null;
	}

	return $action->getActionGroupKey();
	}

	public function getActions($rule_type) {
	$actions = array();
	foreach ($this->getActionsForRuleType($rule_type) as $key => $action) {
	$actions[] = $key;
	}

	return $actions;
	}

	public function getActionNameMap($rule_type) {
	$map = array();
	foreach ($this->getActionsForRuleType($rule_type) as $key => $action) {
	$map[$key] = $action->getHeraldActionName();
	}

	return $map;
	}

	public function willSaveAction(
	HeraldRule $rule,
	HeraldActionRecord $action) {

	$impl = $this->requireActionImplementation($action->getAction());
	$target = $action->getTarget();
	$target = $impl->willSaveActionValue($target);

	$action->setTarget($target);
	}



	/* -( Values )------------------------------------------------------------- */


	public function getValueTypeForFieldAndCondition($field, $condition) {
	return $this->requireFieldImplementation($field)
	->getHeraldFieldValueType($condition);
	}

	public function getValueTypeForAction($action, $rule_type) {
	$impl = $this->requireActionImplementation($action);
	return $impl->getHeraldActionValueType();
	}

	private function buildTokenizerFieldValue(
	PhabricatorTypeaheadDatasource $datasource) {

	$key = 'action.'.get_class($datasource);

	return id(new HeraldTokenizerFieldValue())
	->setKey($key)
	->setDatasource($datasource);
	}

	/* -( Repetition )--------------------------------------------------------- */


	public function getRepetitionOptions() {
	$options = array();

	$options[] = HeraldRule::REPEAT_EVERY;

	// Some rules, like pre-commit rules, only ever fire once. It doesn't
	// make sense to use state-based repetition policies like "only the first
	// time" for these rules.

	if (!$this->isSingleEventAdapter()) {
	$options[] = HeraldRule::REPEAT_FIRST;
	+ $options[] = HeraldRule::REPEAT_CHANGE;
	}

	return $options;
	}

	protected function initializeNewAdapter() {
	$this->setObject($this->newObject());
	return $this;
	}

	/**
	* Does this adapter's event fire only once?
	*
	* Single use adapters (like pre-commit and diff adapters) only fire once,
	* so fields like "Is new object" don't make sense to apply to their content.
	*
	* @return bool
	*/
	public function isSingleEventAdapter() {
	return false;
	}

	public static function getAllAdapters() {
	return id(new PhutilClassMapQuery())
	->setAncestorClass(__CLASS__)
	->setUniqueMethod('getAdapterContentType')
	->setSortMethod('getAdapterSortKey')
	->execute();
	}

	public static function getAdapterForContentType($content_type) {
	$adapters = self::getAllAdapters();

	foreach ($adapters as $adapter) {
	if ($adapter->getAdapterContentType() == $content_type) {
	$adapter = id(clone $adapter);
	$adapter->initializeNewAdapter();
	return $adapter;
	}
	}

	throw new Exception(
	pht(
	'No adapter exists for Herald content type "%s".',
	$content_type));
	}

	public static function getEnabledAdapterMap(PhabricatorUser $viewer) {
	$map = array();

	$adapters = self::getAllAdapters();
	foreach ($adapters as $adapter) {
	if (!$adapter->isAvailableToUser($viewer)) {
	continue;
	}
	$type = $adapter->getAdapterContentType();
	$name = $adapter->getAdapterContentName();
	$map[$type] = $name;
	}

	return $map;
	}

	public function getEditorValueForCondition(
	PhabricatorUser $viewer,
	HeraldCondition $condition) {

	$field = $this->requireFieldImplementation($condition->getFieldName());

	return $field->getEditorValue(
	$viewer,
	$condition->getFieldCondition(),
	$condition->getValue());
	}

	public function getEditorValueForAction(
	PhabricatorUser $viewer,
	HeraldActionRecord $action_record) {

	$action = $this->requireActionImplementation($action_record->getAction());

	return $action->getEditorValue(
	$viewer,
	$action_record->getTarget());
	}

	public function renderRuleAsText(
	HeraldRule $rule,
	PhabricatorHandleList $handles,
	PhabricatorUser $viewer) {

	require_celerity_resource('herald-css');

	$icon = id(new PHUIIconView())
	->setIcon('fa-chevron-circle-right lightgreytext')
	->addClass('herald-list-icon');

	if ($rule->getMustMatchAll()) {
	$match_text = pht('When all of these conditions are met:');
	} else {
	$match_text = pht('When any of these conditions are met:');
	}

	$match_title = phutil_tag(
	'p',
	array(
	'class' => 'herald-list-description',
	),
	$match_text);

	$match_list = array();
	foreach ($rule->getConditions() as $condition) {
	$match_list[] = phutil_tag(
	'div',
	array(
	'class' => 'herald-list-item',
	),
	array(
	$icon,
	$this->renderConditionAsText($condition, $handles, $viewer),
	));
	}

	- if ($rule->isRepeatEvery()) {
	- $action_text =
	- pht('Take these actions every time this rule matches:');
	+ if ($rule->isRepeatFirst()) {
	+ $action_text = pht(
	+ 'Take these actions the first time this rule matches:');
	+ } else if ($rule->isRepeatOnChange()) {
	+ $action_text = pht(
	+ 'Take these actions if this rule did not match the last time:');
	} else {
	- $action_text =
	- pht('Take these actions the first time this rule matches:');
	+ $action_text = pht(
	+ 'Take these actions every time this rule matches:');
	}

	$action_title = phutil_tag(
	'p',
	array(
	'class' => 'herald-list-description',
	),
	$action_text);

	$action_list = array();
	foreach ($rule->getActions() as $action) {
	$action_list[] = phutil_tag(
	'div',
	array(
	'class' => 'herald-list-item',
	),
	array(
	$icon,
	$this->renderActionAsText($viewer, $action, $handles),
	));
	}

	return array(
	$match_title,
	$match_list,
	$action_title,
	$action_list,
	);
	}

	private function renderConditionAsText(
	HeraldCondition $condition,
	PhabricatorHandleList $handles,
	PhabricatorUser $viewer) {

	$field_type = $condition->getFieldName();
	$field = $this->getFieldImplementation($field_type);

	if (!$field) {
	return pht('Unknown Field: "%s"', $field_type);
	}

	$field_name = $field->getHeraldFieldName();

	$condition_type = $condition->getFieldCondition();
	$condition_name = idx($this->getConditionNameMap(), $condition_type);

	$value = $this->renderConditionValueAsText($condition, $handles, $viewer);

	return array(
	$field_name,
	' ',
	$condition_name,
	' ',
	$value,
	);
	}

	private function renderActionAsText(
	PhabricatorUser $viewer,
	HeraldActionRecord $action,
	PhabricatorHandleList $handles) {

	$impl = $this->getActionImplementation($action->getAction());
	if ($impl) {
	$impl->setViewer($viewer);

	$value = $action->getTarget();
	return $impl->renderActionDescription($value);
	}

	$rule_global = HeraldRuleTypeConfig::RULE_TYPE_GLOBAL;

	$action_type = $action->getAction();

	$default = pht('(Unknown Action "%s") equals', $action_type);

	$action_name = idx(
	$this->getActionNameMap($rule_global),
	$action_type,
	$default);

	$target = $this->renderActionTargetAsText($action, $handles);

	return hsprintf(' %s %s', $action_name, $target);
	}

	private function renderConditionValueAsText(
	HeraldCondition $condition,
	PhabricatorHandleList $handles,
	PhabricatorUser $viewer) {

	$field = $this->requireFieldImplementation($condition->getFieldName());

	return $field->renderConditionValue(
	$viewer,
	$condition->getFieldCondition(),
	$condition->getValue());
	}

	private function renderActionTargetAsText(
	HeraldActionRecord $action,
	PhabricatorHandleList $handles) {

	// TODO: This should be driven through HeraldAction.

	$target = $action->getTarget();
	if (!is_array($target)) {
	$target = array($target);
	}
	foreach ($target as $index => $val) {
	switch ($action->getAction()) {
	default:
	$handle = $handles->getHandleIfExists($val);
	if ($handle) {
	$target[$index] = $handle->renderLink();
	}
	break;
	}
	}
	$target = phutil_implode_html(', ', $target);
	return $target;
	}

	/**
	* Given a @{class:HeraldRule}, this function extracts all the phids that
	* we'll want to load as handles later.
	*
	* This function performs a somewhat hacky approach to figuring out what
	* is and is not a phid - try to get the phid type and if the type is
	* not unknown assume its a valid phid.
	*
	* Don't try this at home. Use more strongly typed data at home.
	*
	* Think of the children.
	*/
	public static function getHandlePHIDs(HeraldRule $rule) {
	$phids = array($rule->getAuthorPHID());
	foreach ($rule->getConditions() as $condition) {
	$value = $condition->getValue();
	if (!is_array($value)) {
	$value = array($value);
	}
	foreach ($value as $val) {
	if (phid_get_type($val) !=
	PhabricatorPHIDConstants::PHID_TYPE_UNKNOWN) {
	$phids[] = $val;
	}
	}
	}

	foreach ($rule->getActions() as $action) {
	$target = $action->getTarget();
	if (!is_array($target)) {
	$target = array($target);
	}
	foreach ($target as $val) {
	if (phid_get_type($val) !=
	PhabricatorPHIDConstants::PHID_TYPE_UNKNOWN) {
	$phids[] = $val;
	}
	}
	}

	if ($rule->isObjectRule()) {
	$phids[] = $rule->getTriggerObjectPHID();
	}

	return $phids;
	}

	/* -( Applying Effects )--------------------------------------------------- */


	/**
	* @task apply
	*/
	protected function applyStandardEffect(HeraldEffect $effect) {
	$action = $effect->getAction();
	$rule_type = $effect->getRule()->getRuleType();

	$impl = $this->getActionImplementation($action);
	if (!$impl) {
	return new HeraldApplyTranscript(
	$effect,
	false,
	array(
	array(
	HeraldAction::DO_STANDARD_INVALID_ACTION,
	$action,
	),
	));
	}

	if (!$impl->supportsRuleType($rule_type)) {
	return new HeraldApplyTranscript(
	$effect,
	false,
	array(
	array(
	HeraldAction::DO_STANDARD_WRONG_RULE_TYPE,
	$rule_type,
	),
	));
	}

	$impl->applyEffect($this->getObject(), $effect);
	return $impl->getApplyTranscript($effect);
	}

	public function loadEdgePHIDs($type) {
	if (!isset($this->edgeCache[$type])) {
	$phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$this->getObject()->getPHID(),
	$type);

	$this->edgeCache[$type] = array_fuse($phids);
	}
	return $this->edgeCache[$type];
	}


	/* -( Forbidden Actions )-------------------------------------------------- */


	final public function getForbiddenActions() {
	return array_keys($this->forbiddenActions);
	}

	final public function setForbiddenAction($action, $reason) {
	$this->forbiddenActions[$action] = $reason;
	return $this;
	}

	final public function getRequiredFieldStates($field_key) {
	return $this->requireFieldImplementation($field_key)
	->getRequiredAdapterStates();
	}

	final public function getRequiredActionStates($action_key) {
	return $this->requireActionImplementation($action_key)
	->getRequiredAdapterStates();
	}

	final public function getForbiddenReason($action) {
	if (!isset($this->forbiddenActions[$action])) {
	throw new Exception(
	pht(
	'Action "%s" is not forbidden!',
	$action));
	}

	return $this->forbiddenActions[$action];
	}

	}
	diff --git a/src/applications/herald/controller/HeraldRuleController.php b/src/applications/herald/controller/HeraldRuleController.php
	index 906afe835e..c61c29e90e 100644
	--- a/src/applications/herald/controller/HeraldRuleController.php
	+++ b/src/applications/herald/controller/HeraldRuleController.php
	@@ -1,724 +1,724 @@
	<?php

	final class HeraldRuleController extends HeraldController {

	public function handleRequest(AphrontRequest $request) {
	$viewer = $request->getViewer();
	$id = $request->getURIData('id');

	$content_type_map = HeraldAdapter::getEnabledAdapterMap($viewer);
	$rule_type_map = HeraldRuleTypeConfig::getRuleTypeMap();

	if ($id) {
	$rule = id(new HeraldRuleQuery())
	->setViewer($viewer)
	->withIDs(array($id))
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->executeOne();
	if (!$rule) {
	return new Aphront404Response();
	}
	$cancel_uri = '/'.$rule->getMonogram();
	} else {
	$new_uri = $this->getApplicationURI('new/');

	$rule = new HeraldRule();
	$rule->setAuthorPHID($viewer->getPHID());
	$rule->setMustMatchAll(1);

	$content_type = $request->getStr('content_type');
	$rule->setContentType($content_type);

	$rule_type = $request->getStr('rule_type');
	if (!isset($rule_type_map[$rule_type])) {
	return $this->newDialog()
	->setTitle(pht('Invalid Rule Type'))
	->appendParagraph(
	pht(
	'The selected rule type ("%s") is not recognized by Herald.',
	$rule_type))
	->addCancelButton($new_uri);
	}
	$rule->setRuleType($rule_type);

	try {
	$adapter = HeraldAdapter::getAdapterForContentType(
	$rule->getContentType());
	} catch (Exception $ex) {
	return $this->newDialog()
	->setTitle(pht('Invalid Content Type'))
	->appendParagraph(
	pht(
	'The selected content type ("%s") is not recognized by '.
	'Herald.',
	$rule->getContentType()))
	->addCancelButton($new_uri);
	}

	if (!$adapter->supportsRuleType($rule->getRuleType())) {
	return $this->newDialog()
	->setTitle(pht('Rule/Content Mismatch'))
	->appendParagraph(
	pht(
	'The selected rule type ("%s") is not supported by the selected '.
	'content type ("%s").',
	$rule->getRuleType(),
	$rule->getContentType()))
	->addCancelButton($new_uri);
	}

	if ($rule->isObjectRule()) {
	$rule->setTriggerObjectPHID($request->getStr('targetPHID'));
	$object = id(new PhabricatorObjectQuery())
	->setViewer($viewer)
	->withPHIDs(array($rule->getTriggerObjectPHID()))
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->executeOne();
	if (!$object) {
	throw new Exception(
	pht('No valid object provided for object rule!'));
	}

	if (!$adapter->canTriggerOnObject($object)) {
	throw new Exception(
	pht('Object is of wrong type for adapter!'));
	}
	}

	$cancel_uri = $this->getApplicationURI();
	}

	if ($rule->isGlobalRule()) {
	$this->requireApplicationCapability(
	HeraldManageGlobalRulesCapability::CAPABILITY);
	}

	$adapter = HeraldAdapter::getAdapterForContentType($rule->getContentType());

	$local_version = id(new HeraldRule())->getConfigVersion();
	if ($rule->getConfigVersion() > $local_version) {
	throw new Exception(
	pht(
	'This rule was created with a newer version of Herald. You can not '.
	'view or edit it in this older version. Upgrade your Phabricator '.
	'deployment.'));
	}

	// Upgrade rule version to our version, since we might add newly-defined
	// conditions, etc.
	$rule->setConfigVersion($local_version);

	$rule_conditions = $rule->loadConditions();
	$rule_actions = $rule->loadActions();

	$rule->attachConditions($rule_conditions);
	$rule->attachActions($rule_actions);

	$e_name = true;
	$errors = array();
	if ($request->isFormPost() && $request->getStr('save')) {
	list($e_name, $errors) = $this->saveRule($adapter, $rule, $request);
	if (!$errors) {
	$id = $rule->getID();
	$uri = '/'.$rule->getMonogram();
	return id(new AphrontRedirectResponse())->setURI($uri);
	}
	}

	$must_match_selector = $this->renderMustMatchSelector($rule);
	$repetition_selector = $this->renderRepetitionSelector($rule, $adapter);

	$handles = $this->loadHandlesForRule($rule);

	require_celerity_resource('herald-css');

	$content_type_name = $content_type_map[$rule->getContentType()];
	$rule_type_name = $rule_type_map[$rule->getRuleType()];

	$form = id(new AphrontFormView())
	->setUser($viewer)
	->setID('herald-rule-edit-form')
	->addHiddenInput('content_type', $rule->getContentType())
	->addHiddenInput('rule_type', $rule->getRuleType())
	->addHiddenInput('save', 1)
	->appendChild(
	// Build this explicitly (instead of using addHiddenInput())
	// so we can add a sigil to it.
	javelin_tag(
	'input',
	array(
	'type' => 'hidden',
	'name' => 'rule',
	'sigil' => 'rule',
	)))
	->appendChild(
	id(new AphrontFormTextControl())
	->setLabel(pht('Rule Name'))
	->setName('name')
	->setError($e_name)
	->setValue($rule->getName()));

	$trigger_object_control = false;
	if ($rule->isObjectRule()) {
	$trigger_object_control = id(new AphrontFormStaticControl())
	->setValue(
	pht(
	'This rule triggers for %s.',
	$handles[$rule->getTriggerObjectPHID()]->renderLink()));
	}


	$form
	->appendChild(
	id(new AphrontFormMarkupControl())
	->setValue(pht(
	'This %s rule triggers for %s.',
	phutil_tag('strong', array(), $rule_type_name),
	phutil_tag('strong', array(), $content_type_name))))
	->appendChild($trigger_object_control)
	->appendChild(
	id(new PHUIFormInsetView())
	->setTitle(pht('Conditions'))
	->setRightButton(javelin_tag(
	'a',
	array(
	'href' => '#',
	'class' => 'button button-green',
	'sigil' => 'create-condition',
	'mustcapture' => true,
	),
	pht('New Condition')))
	->setDescription(
	pht('When %s these conditions are met:', $must_match_selector))
	->setContent(javelin_tag(
	'table',
	array(
	'sigil' => 'rule-conditions',
	'class' => 'herald-condition-table',
	),
	'')))
	->appendChild(
	id(new PHUIFormInsetView())
	->setTitle(pht('Action'))
	->setRightButton(javelin_tag(
	'a',
	array(
	'href' => '#',
	'class' => 'button button-green',
	'sigil' => 'create-action',
	'mustcapture' => true,
	),
	pht('New Action')))
	->setDescription(pht(
	- 'Take these actions %s this rule matches:',
	+ 'Take these actions %s',
	$repetition_selector))
	->setContent(javelin_tag(
	'table',
	array(
	'sigil' => 'rule-actions',
	'class' => 'herald-action-table',
	),
	'')))
	->appendChild(
	id(new AphrontFormSubmitControl())
	->setValue(pht('Save Rule'))
	->addCancelButton($cancel_uri));

	$this->setupEditorBehavior($rule, $handles, $adapter);

	$title = $rule->getID()
	? pht('Edit Herald Rule: %s', $rule->getName())
	: pht('Create Herald Rule: %s', idx($content_type_map, $content_type));

	$form_box = id(new PHUIObjectBoxView())
	->setHeaderText($title)
	->setBackground(PHUIObjectBoxView::WHITE_CONFIG)
	->setFormErrors($errors)
	->setForm($form);

	$crumbs = $this
	->buildApplicationCrumbs()
	->addTextCrumb($title)
	->setBorder(true);

	$view = id(new PHUITwoColumnView())
	->setFooter($form_box);

	return $this->newPage()
	->setTitle($title)
	->setCrumbs($crumbs)
	->appendChild(
	array(
	$view,
	));
	}

	private function saveRule(HeraldAdapter $adapter, $rule, $request) {
	$new_name = $request->getStr('name');
	$match_all = ($request->getStr('must_match') == 'all');

	$repetition_policy_param = $request->getStr('repetition_policy');

	$e_name = true;
	$errors = array();

	if (!strlen($new_name)) {
	$e_name = pht('Required');
	$errors[] = pht('Rule must have a name.');
	}

	$data = null;
	try {
	$data = phutil_json_decode($request->getStr('rule'));
	} catch (PhutilJSONParserException $ex) {
	throw new PhutilProxyException(
	pht('Failed to decode rule data.'),
	$ex);
	}

	if (!is_array($data) \|\|
	!$data['conditions'] \|\|
	!$data['actions']) {
	throw new Exception(pht('Failed to decode rule data.'));
	}

	$conditions = array();
	foreach ($data['conditions'] as $condition) {
	if ($condition === null) {
	// We manage this as a sparse array on the client, so may receive
	// NULL if conditions have been removed.
	continue;
	}

	$obj = new HeraldCondition();
	$obj->setFieldName($condition[0]);
	$obj->setFieldCondition($condition[1]);

	if (is_array($condition[2])) {
	$obj->setValue(array_keys($condition[2]));
	} else {
	$obj->setValue($condition[2]);
	}

	try {
	$adapter->willSaveCondition($obj);
	} catch (HeraldInvalidConditionException $ex) {
	$errors[] = $ex->getMessage();
	}

	$conditions[] = $obj;
	}

	$actions = array();
	foreach ($data['actions'] as $action) {
	if ($action === null) {
	// Sparse on the client; removals can give us NULLs.
	continue;
	}

	if (!isset($action[1])) {
	// Legitimate for any action which doesn't need a target, like
	// "Do nothing".
	$action[1] = null;
	}

	$obj = new HeraldActionRecord();
	$obj->setAction($action[0]);
	$obj->setTarget($action[1]);

	try {
	$adapter->willSaveAction($rule, $obj);
	} catch (HeraldInvalidActionException $ex) {
	$errors[] = $ex->getMessage();
	}

	$actions[] = $obj;
	}

	if (!$errors) {
	$new_state = id(new HeraldRuleSerializer())->serializeRuleComponents(
	$match_all,
	$conditions,
	$actions,
	$repetition_policy_param);

	$xactions = array();
	$xactions[] = id(new HeraldRuleTransaction())
	->setTransactionType(HeraldRuleTransaction::TYPE_EDIT)
	->setNewValue($new_state);
	$xactions[] = id(new HeraldRuleTransaction())
	->setTransactionType(HeraldRuleTransaction::TYPE_NAME)
	->setNewValue($new_name);

	try {
	id(new HeraldRuleEditor())
	->setActor($this->getViewer())
	->setContinueOnNoEffect(true)
	->setContentSourceFromRequest($request)
	->applyTransactions($rule, $xactions);
	return array(null, null);
	} catch (Exception $ex) {
	$errors[] = $ex->getMessage();
	}
	}

	// mutate current rule, so it would be sent to the client in the right state
	$rule->setMustMatchAll((int)$match_all);
	$rule->setName($new_name);
	$rule->setRepetitionPolicyStringConstant($repetition_policy_param);
	$rule->attachConditions($conditions);
	$rule->attachActions($actions);

	return array($e_name, $errors);
	}

	private function setupEditorBehavior(
	HeraldRule $rule,
	array $handles,
	HeraldAdapter $adapter) {

	$all_rules = $this->loadRulesThisRuleMayDependUpon($rule);
	$all_rules = mpull($all_rules, 'getName', 'getPHID');
	asort($all_rules);

	$all_fields = $adapter->getFieldNameMap();
	$all_conditions = $adapter->getConditionNameMap();
	$all_actions = $adapter->getActionNameMap($rule->getRuleType());

	$fields = $adapter->getFields();
	$field_map = array_select_keys($all_fields, $fields);

	// Populate any fields which exist in the rule but which we don't know the
	// names of, so that saving a rule without touching anything doesn't change
	// it.
	foreach ($rule->getConditions() as $condition) {
	$field_name = $condition->getFieldName();

	if (empty($field_map[$field_name])) {
	$field_map[$field_name] = pht('<Unknown Field "%s">', $field_name);
	}
	}

	$actions = $adapter->getActions($rule->getRuleType());
	$action_map = array_select_keys($all_actions, $actions);

	// Populate any actions which exist in the rule but which we don't know the
	// names of, so that saving a rule without touching anything doesn't change
	// it.
	foreach ($rule->getActions() as $action) {
	$action_name = $action->getAction();

	if (empty($action_map[$action_name])) {
	$action_map[$action_name] = pht('<Unknown Action "%s">', $action_name);
	}
	}

	$config_info = array();
	$config_info['fields'] = $this->getFieldGroups($adapter, $field_map);
	$config_info['conditions'] = $all_conditions;
	$config_info['actions'] = $this->getActionGroups($adapter, $action_map);
	$config_info['valueMap'] = array();

	foreach ($field_map as $field => $name) {
	try {
	$field_conditions = $adapter->getConditionsForField($field);
	} catch (Exception $ex) {
	$field_conditions = array(HeraldAdapter::CONDITION_UNCONDITIONALLY);
	}
	$config_info['conditionMap'][$field] = $field_conditions;
	}

	foreach ($field_map as $field => $fname) {
	foreach ($config_info['conditionMap'][$field] as $condition) {
	$value_key = $adapter->getValueTypeForFieldAndCondition(
	$field,
	$condition);

	if ($value_key instanceof HeraldFieldValue) {
	$value_key->setViewer($this->getViewer());

	$spec = $value_key->getControlSpecificationDictionary();
	$value_key = $value_key->getFieldValueKey();
	$config_info['valueMap'][$value_key] = $spec;
	}

	$config_info['values'][$field][$condition] = $value_key;
	}
	}

	$config_info['rule_type'] = $rule->getRuleType();

	foreach ($action_map as $action => $name) {
	try {
	$value_key = $adapter->getValueTypeForAction(
	$action,
	$rule->getRuleType());
	} catch (Exception $ex) {
	$value_key = new HeraldEmptyFieldValue();
	}

	if ($value_key instanceof HeraldFieldValue) {
	$value_key->setViewer($this->getViewer());

	$spec = $value_key->getControlSpecificationDictionary();
	$value_key = $value_key->getFieldValueKey();
	$config_info['valueMap'][$value_key] = $spec;
	}

	$config_info['targets'][$action] = $value_key;
	}

	$default_group = head($config_info['fields']);
	$default_field = head_key($default_group['options']);
	$default_condition = head($config_info['conditionMap'][$default_field]);
	$default_actions = head($config_info['actions']);
	$default_action = head_key($default_actions['options']);

	if ($rule->getConditions()) {
	$serial_conditions = array();
	foreach ($rule->getConditions() as $condition) {
	$value = $adapter->getEditorValueForCondition(
	$this->getViewer(),
	$condition);

	$serial_conditions[] = array(
	$condition->getFieldName(),
	$condition->getFieldCondition(),
	$value,
	);
	}
	} else {
	$serial_conditions = array(
	array($default_field, $default_condition, null),
	);
	}

	if ($rule->getActions()) {
	$serial_actions = array();
	foreach ($rule->getActions() as $action) {
	$value = $adapter->getEditorValueForAction(
	$this->getViewer(),
	$action);

	$serial_actions[] = array(
	$action->getAction(),
	$value,
	);
	}
	} else {
	$serial_actions = array(
	array($default_action, null),
	);
	}

	Javelin::initBehavior(
	'herald-rule-editor',
	array(
	'root' => 'herald-rule-edit-form',
	'default' => array(
	'field' => $default_field,
	'condition' => $default_condition,
	'action' => $default_action,
	),
	'conditions' => (object)$serial_conditions,
	'actions' => (object)$serial_actions,
	'template' => $this->buildTokenizerTemplates() + array(
	'rules' => $all_rules,
	),
	'info' => $config_info,
	));
	}

	private function loadHandlesForRule($rule) {
	$phids = array();

	foreach ($rule->getActions() as $action) {
	if (!is_array($action->getTarget())) {
	continue;
	}
	foreach ($action->getTarget() as $target) {
	$target = (array)$target;
	foreach ($target as $phid) {
	$phids[] = $phid;
	}
	}
	}

	foreach ($rule->getConditions() as $condition) {
	$value = $condition->getValue();
	if (is_array($value)) {
	foreach ($value as $phid) {
	$phids[] = $phid;
	}
	}
	}

	$phids[] = $rule->getAuthorPHID();

	if ($rule->isObjectRule()) {
	$phids[] = $rule->getTriggerObjectPHID();
	}

	return $this->loadViewerHandles($phids);
	}


	/**
	* Render the selector for the "When (all of \| any of) these conditions are
	* met:" element.
	*/
	private function renderMustMatchSelector($rule) {
	return AphrontFormSelectControl::renderSelectTag(
	$rule->getMustMatchAll() ? 'all' : 'any',
	array(
	'all' => pht('all of'),
	'any' => pht('any of'),
	),
	array(
	'name' => 'must_match',
	));
	}


	/**
	* Render the selector for "Take these actions (every time \| only the first
	* time) this rule matches..." element.
	*/
	private function renderRepetitionSelector($rule, HeraldAdapter $adapter) {
	$repetition_policy = $rule->getRepetitionPolicyStringConstant();

	$repetition_options = $adapter->getRepetitionOptions();
	$repetition_names = HeraldRule::getRepetitionPolicySelectOptionMap();
	$repetition_map = array_select_keys($repetition_names, $repetition_options);

	if (count($repetition_map) < 2) {
	return head($repetition_names);
	} else {
	return AphrontFormSelectControl::renderSelectTag(
	$repetition_policy,
	$repetition_map,
	array(
	'name' => 'repetition_policy',
	));
	}
	}


	protected function buildTokenizerTemplates() {
	$template = new AphrontTokenizerTemplateView();
	$template = $template->render();
	return array(
	'markup' => $template,
	);
	}


	/**
	* Load rules for the "Another Herald rule..." condition dropdown, which
	* allows one rule to depend upon the success or failure of another rule.
	*/
	private function loadRulesThisRuleMayDependUpon(HeraldRule $rule) {
	$viewer = $this->getRequest()->getUser();

	// Any rule can depend on a global rule.
	$all_rules = id(new HeraldRuleQuery())
	->setViewer($viewer)
	->withRuleTypes(array(HeraldRuleTypeConfig::RULE_TYPE_GLOBAL))
	->withContentTypes(array($rule->getContentType()))
	->execute();

	if ($rule->isObjectRule()) {
	// Object rules may depend on other rules for the same object.
	$all_rules += id(new HeraldRuleQuery())
	->setViewer($viewer)
	->withRuleTypes(array(HeraldRuleTypeConfig::RULE_TYPE_OBJECT))
	->withContentTypes(array($rule->getContentType()))
	->withTriggerObjectPHIDs(array($rule->getTriggerObjectPHID()))
	->execute();
	}

	if ($rule->isPersonalRule()) {
	// Personal rules may depend upon your other personal rules.
	$all_rules += id(new HeraldRuleQuery())
	->setViewer($viewer)
	->withRuleTypes(array(HeraldRuleTypeConfig::RULE_TYPE_PERSONAL))
	->withContentTypes(array($rule->getContentType()))
	->withAuthorPHIDs(array($rule->getAuthorPHID()))
	->execute();
	}

	// mark disabled rules as disabled since they are not useful as such;
	// don't filter though to keep edit cases sane / expected
	foreach ($all_rules as $current_rule) {
	if ($current_rule->getIsDisabled()) {
	$current_rule->makeEphemeral();
	$current_rule->setName($rule->getName().' '.pht('(Disabled)'));
	}
	}

	// A rule can not depend upon itself.
	unset($all_rules[$rule->getID()]);

	return $all_rules;
	}

	private function getFieldGroups(HeraldAdapter $adapter, array $field_map) {
	$group_map = array();
	foreach ($field_map as $field_key => $field_name) {
	$group_key = $adapter->getFieldGroupKey($field_key);
	$group_map[$group_key][$field_key] = $field_name;
	}

	return $this->getGroups(
	$group_map,
	HeraldFieldGroup::getAllFieldGroups());
	}

	private function getActionGroups(HeraldAdapter $adapter, array $action_map) {
	$group_map = array();
	foreach ($action_map as $action_key => $action_name) {
	$group_key = $adapter->getActionGroupKey($action_key);
	$group_map[$group_key][$action_key] = $action_name;
	}

	return $this->getGroups(
	$group_map,
	HeraldActionGroup::getAllActionGroups());
	}

	private function getGroups(array $item_map, array $group_list) {
	assert_instances_of($group_list, 'HeraldGroup');

	$groups = array();
	foreach ($item_map as $group_key => $options) {
	asort($options);

	$group_object = idx($group_list, $group_key);
	if ($group_object) {
	$group_label = $group_object->getGroupLabel();
	$group_order = $group_object->getSortKey();
	} else {
	$group_label = nonempty($group_key, pht('Other'));
	$group_order = 'Z';
	}

	$groups[] = array(
	'label' => $group_label,
	'options' => $options,
	'order' => $group_order,
	);
	}

	return array_values(isort($groups, 'order'));
	}


	}
	diff --git a/src/applications/herald/engine/HeraldEngine.php b/src/applications/herald/engine/HeraldEngine.php
	index afeba459ff..739e83e4e8 100644
	--- a/src/applications/herald/engine/HeraldEngine.php
	+++ b/src/applications/herald/engine/HeraldEngine.php
	@@ -1,567 +1,633 @@
	<?php

	final class HeraldEngine extends Phobject {

	protected $rules = array();
	protected $results = array();
	protected $stack = array();
	protected $activeRule;
	protected $transcript;

	protected $fieldCache = array();
	protected $object;
	private $dryRun;

	private $forbiddenFields = array();
	private $forbiddenActions = array();
	+ private $skipEffects = array();

	public function setDryRun($dry_run) {
	$this->dryRun = $dry_run;
	return $this;
	}

	public function getDryRun() {
	return $this->dryRun;
	}

	public function getRule($phid) {
	return idx($this->rules, $phid);
	}

	public function loadRulesForAdapter(HeraldAdapter $adapter) {
	return id(new HeraldRuleQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withDisabled(false)
	->withContentTypes(array($adapter->getAdapterContentType()))
	->needConditionsAndActions(true)
	->needAppliedToPHIDs(array($adapter->getPHID()))
	->needValidateAuthors(true)
	->execute();
	}

	public static function loadAndApplyRules(HeraldAdapter $adapter) {
	$engine = new HeraldEngine();

	$rules = $engine->loadRulesForAdapter($adapter);
	$effects = $engine->applyRules($rules, $adapter);
	$engine->applyEffects($effects, $adapter, $rules);

	return $engine->getTranscript();
	}

	public function applyRules(array $rules, HeraldAdapter $object) {
	assert_instances_of($rules, 'HeraldRule');
	$t_start = microtime(true);

	// Rules execute in a well-defined order: sort them into execution order.
	$rules = msort($rules, 'getRuleExecutionOrderSortKey');
	$rules = mpull($rules, null, 'getPHID');

	$this->transcript = new HeraldTranscript();
	$this->transcript->setObjectPHID((string)$object->getPHID());
	$this->fieldCache = array();
	$this->results = array();
	$this->rules = $rules;
	$this->object = $object;

	$effects = array();
	foreach ($rules as $phid => $rule) {
	$this->stack = array();

	$is_first_only = $rule->isRepeatFirst();

	try {
	if (!$this->getDryRun() &&
	$is_first_only &&
	$rule->getRuleApplied($object->getPHID())) {
	// This is not a dry run, and this rule is only supposed to be
	// applied a single time, and it's already been applied...
	// That means automatic failure.
	$this->newRuleTranscript($rule)
	->setResult(false)
	->setReason(
	pht(
	'This rule is only supposed to be repeated a single time, '.
	'and it has already been applied.'));

	$rule_matches = false;
	} else {
	if ($this->isForbidden($rule, $object)) {
	$this->newRuleTranscript($rule)
	->setResult(HeraldRuleTranscript::RESULT_FORBIDDEN)
	->setReason(
	pht(
	'Object state is not compatible with rule.'));

	$rule_matches = false;
	} else {
	$rule_matches = $this->doesRuleMatch($rule, $object);
	}
	}
	} catch (HeraldRecursiveConditionsException $ex) {
	$names = array();
	foreach ($this->stack as $rule_phid => $ignored) {
	$names[] = '"'.$rules[$rule_phid]->getName().'"';
	}
	$names = implode(', ', $names);
	foreach ($this->stack as $rule_phid => $ignored) {
	$this->newRuleTranscript($rules[$rule_phid])
	->setResult(false)
	->setReason(
	pht(
	"Rules %s are recursively dependent upon one another! ".
	"Don't do this! You have formed an unresolvable cycle in the ".
	"dependency graph!",
	$names));
	}
	$rule_matches = false;
	}
	$this->results[$phid] = $rule_matches;

	if ($rule_matches) {
	foreach ($this->getRuleEffects($rule, $object) as $effect) {
	$effects[] = $effect;
	}
	}
	}

	$object_transcript = new HeraldObjectTranscript();
	$object_transcript->setPHID($object->getPHID());
	$object_transcript->setName($object->getHeraldName());
	$object_transcript->setType($object->getAdapterContentType());
	$object_transcript->setFields($this->fieldCache);

	$this->transcript->setObjectTranscript($object_transcript);

	$t_end = microtime(true);

	$this->transcript->setDuration($t_end - $t_start);

	return $effects;
	}

	public function applyEffects(
	array $effects,
	HeraldAdapter $adapter,
	array $rules) {
	assert_instances_of($effects, 'HeraldEffect');
	assert_instances_of($rules, 'HeraldRule');

	$this->transcript->setDryRun((int)$this->getDryRun());

	if ($this->getDryRun()) {
	$xscripts = array();
	foreach ($effects as $effect) {
	$xscripts[] = new HeraldApplyTranscript(
	$effect,
	false,
	pht('This was a dry run, so no actions were actually taken.'));
	}
	} else {
	$xscripts = $adapter->applyHeraldEffects($effects);
	}

	assert_instances_of($xscripts, 'HeraldApplyTranscript');
	foreach ($xscripts as $apply_xscript) {
	$this->transcript->addApplyTranscript($apply_xscript);
	}

	// For dry runs, don't mark the rule as having applied to the object.
	if ($this->getDryRun()) {
	return;
	}

	- $rules = mpull($rules, null, 'getID');
	- $applied_ids = array();
	+ // Update the "applied" state table. How this table works depends on the
	+ // repetition policy for the rule.
	+ //
	+ // REPEAT_EVERY: We delete existing rows for the rule, then write nothing.
	+ // This policy doesn't use any state.
	+ //
	+ // REPEAT_FIRST: We keep existing rows, then write additional rows for
	+ // rules which fired. This policy accumulates state over the life of the
	+ // object.
	+ //
	+ // REPEAT_CHANGE: We delete existing rows, then write all the rows which
	+ // matched. This policy only uses the state from the previous run.

	- // Mark all the rules that have had their effects applied as having been
	- // executed for the current object.
	+ $rules = mpull($rules, null, 'getID');
	$rule_ids = mpull($xscripts, 'getRuleID');

	+ $delete_ids = array();
	+ foreach ($rules as $rule_id => $rule) {
	+ if ($rule->isRepeatFirst()) {
	+ continue;
	+ }
	+ $delete_ids[] = $rule_id;
	+ }
	+
	+ $applied_ids = array();
	foreach ($rule_ids as $rule_id) {
	if (!$rule_id) {
	// Some apply transcripts are purely informational and not associated
	// with a rule, e.g. carryover emails from earlier revisions.
	continue;
	}

	$rule = idx($rules, $rule_id);
	if (!$rule) {
	continue;
	}

	- if ($rule->isRepeatFirst()) {
	+ if ($rule->isRepeatFirst() \|\| $rule->isRepeatOnChange()) {
	$applied_ids[] = $rule_id;
	}
	}

	- if ($applied_ids) {
	+ // Also include "only if this rule did not match the last time" rules
	+ // which matched but were skipped in the "applied" list.
	+ foreach ($this->skipEffects as $rule_id => $ignored) {
	+ $applied_ids[] = $rule_id;
	+ }
	+
	+ if ($delete_ids \|\| $applied_ids) {
	$conn_w = id(new HeraldRule())->establishConnection('w');
	- $sql = array();
	- foreach ($applied_ids as $id) {
	- $sql[] = qsprintf(
	+
	+ if ($delete_ids) {
	+ queryfx(
	$conn_w,
	- '(%s, %d)',
	+ 'DELETE FROM %T WHERE phid = %s AND ruleID IN (%Ld)',
	+ HeraldRule::TABLE_RULE_APPLIED,
	$adapter->getPHID(),
	- $id);
	+ $delete_ids);
	+ }
	+
	+ if ($applied_ids) {
	+ $sql = array();
	+ foreach ($applied_ids as $id) {
	+ $sql[] = qsprintf(
	+ $conn_w,
	+ '(%s, %d)',
	+ $adapter->getPHID(),
	+ $id);
	+ }
	+ queryfx(
	+ $conn_w,
	+ 'INSERT IGNORE INTO %T (phid, ruleID) VALUES %Q',
	+ HeraldRule::TABLE_RULE_APPLIED,
	+ implode(', ', $sql));
	}
	- queryfx(
	- $conn_w,
	- 'INSERT IGNORE INTO %T (phid, ruleID) VALUES %Q',
	- HeraldRule::TABLE_RULE_APPLIED,
	- implode(', ', $sql));
	}
	}

	public function getTranscript() {
	$this->transcript->save();
	return $this->transcript;
	}

	public function doesRuleMatch(
	HeraldRule $rule,
	HeraldAdapter $object) {

	$phid = $rule->getPHID();

	if (isset($this->results[$phid])) {
	// If we've already evaluated this rule because another rule depends
	// on it, we don't need to reevaluate it.
	return $this->results[$phid];
	}

	if (isset($this->stack[$phid])) {
	// We've recursed, fail all of the rules on the stack. This happens when
	// there's a dependency cycle with "Rule conditions match for rule ..."
	// conditions.
	foreach ($this->stack as $rule_phid => $ignored) {
	$this->results[$rule_phid] = false;
	}
	throw new HeraldRecursiveConditionsException();
	}

	$this->stack[$phid] = true;

	$all = $rule->getMustMatchAll();

	$conditions = $rule->getConditions();

	$result = null;

	$local_version = id(new HeraldRule())->getConfigVersion();
	if ($rule->getConfigVersion() > $local_version) {
	$reason = pht(
	'Rule could not be processed, it was created with a newer version '.
	'of Herald.');
	$result = false;
	} else if (!$conditions) {
	$reason = pht(
	'Rule failed automatically because it has no conditions.');
	$result = false;
	} else if (!$rule->hasValidAuthor()) {
	$reason = pht(
	'Rule failed automatically because its owner is invalid '.
	'or disabled.');
	$result = false;
	} else if (!$this->canAuthorViewObject($rule, $object)) {
	$reason = pht(
	'Rule failed automatically because it is a personal rule and its '.
	'owner can not see the object.');
	$result = false;
	} else if (!$this->canRuleApplyToObject($rule, $object)) {
	$reason = pht(
	'Rule failed automatically because it is an object rule which is '.
	'not relevant for this object.');
	$result = false;
	} else {
	foreach ($conditions as $condition) {
	try {
	$this->getConditionObjectValue($condition, $object);
	} catch (Exception $ex) {
	$reason = pht(
	'Field "%s" does not exist!',
	$condition->getFieldName());
	$result = false;
	break;
	}

	$match = $this->doesConditionMatch($rule, $condition, $object);

	if (!$all && $match) {
	$reason = pht('Any condition matched.');
	$result = true;
	break;
	}

	if ($all && !$match) {
	$reason = pht('Not all conditions matched.');
	$result = false;
	break;
	}
	}

	if ($result === null) {
	if ($all) {
	$reason = pht('All conditions matched.');
	$result = true;
	} else {
	$reason = pht('No conditions matched.');
	$result = false;
	}
	}
	}

	+ // If this rule matched, and is set to run "if it did not match the last
	+ // time", and we matched the last time, we're going to return a match in
	+ // the transcript but set a flag so we don't actually apply any effects.
	+
	+ // We need the rule to match so that storage gets updated properly. If we
	+ // just pretend the rule didn't match it won't cause any effects (which
	+ // is correct), but it also won't set the "it matched" flag in storage,
	+ // so the next run after this one would incorrectly trigger again.
	+
	+ $is_dry_run = $this->getDryRun();
	+ if ($result && !$is_dry_run) {
	+ $is_on_change = $rule->isRepeatOnChange();
	+ if ($is_on_change) {
	+ $did_apply = $rule->getRuleApplied($object->getPHID());
	+ if ($did_apply) {
	+ $reason = pht(
	+ 'This rule matched, but did not take any actions because it '.
	+ 'is configured to act only if it did not match the last time.');
	+
	+ $this->skipEffects[$rule->getID()] = true;
	+ }
	+ }
	+ }
	+
	$this->newRuleTranscript($rule)
	->setResult($result)
	->setReason($reason);

	return $result;
	}

	protected function doesConditionMatch(
	HeraldRule $rule,
	HeraldCondition $condition,
	HeraldAdapter $object) {

	$object_value = $this->getConditionObjectValue($condition, $object);
	$transcript = $this->newConditionTranscript($rule, $condition);

	try {
	$result = $object->doesConditionMatch(
	$this,
	$rule,
	$condition,
	$object_value);
	} catch (HeraldInvalidConditionException $ex) {
	$result = false;
	$transcript->setNote($ex->getMessage());
	}

	$transcript->setResult($result);

	return $result;
	}

	protected function getConditionObjectValue(
	HeraldCondition $condition,
	HeraldAdapter $object) {

	$field = $condition->getFieldName();

	return $this->getObjectFieldValue($field);
	}

	public function getObjectFieldValue($field) {
	if (!array_key_exists($field, $this->fieldCache)) {
	$this->fieldCache[$field] = $this->object->getHeraldField($field);
	}

	return $this->fieldCache[$field];
	}

	protected function getRuleEffects(
	HeraldRule $rule,
	HeraldAdapter $object) {

	+ $rule_id = $rule->getID();
	+ if (isset($this->skipEffects[$rule_id])) {
	+ return array();
	+ }
	+
	$effects = array();
	foreach ($rule->getActions() as $action) {
	$effect = id(new HeraldEffect())
	->setObjectPHID($object->getPHID())
	->setAction($action->getAction())
	->setTarget($action->getTarget())
	->setRule($rule);

	$name = $rule->getName();
	$id = $rule->getID();
	$effect->setReason(
	pht(
	'Conditions were met for %s',
	"H{$id} {$name}"));

	$effects[] = $effect;
	}
	return $effects;
	}

	private function canAuthorViewObject(
	HeraldRule $rule,
	HeraldAdapter $adapter) {

	// Authorship is irrelevant for global rules and object rules.
	if ($rule->isGlobalRule() \|\| $rule->isObjectRule()) {
	return true;
	}

	// The author must be able to create rules for the adapter's content type.
	// In particular, this means that the application must be installed and
	// accessible to the user. For example, if a user writes a Differential
	// rule and then loses access to Differential, this disables the rule.
	$enabled = HeraldAdapter::getEnabledAdapterMap($rule->getAuthor());
	if (empty($enabled[$adapter->getAdapterContentType()])) {
	return false;
	}

	// Finally, the author must be able to see the object itself. You can't
	// write a personal rule that CC's you on revisions you wouldn't otherwise
	// be able to see, for example.
	$object = $adapter->getObject();
	return PhabricatorPolicyFilter::hasCapability(
	$rule->getAuthor(),
	$object,
	PhabricatorPolicyCapability::CAN_VIEW);
	}

	private function canRuleApplyToObject(
	HeraldRule $rule,
	HeraldAdapter $adapter) {

	// Rules which are not object rules can apply to anything.
	if (!$rule->isObjectRule()) {
	return true;
	}

	$trigger_phid = $rule->getTriggerObjectPHID();
	$object_phids = $adapter->getTriggerObjectPHIDs();

	if ($object_phids) {
	if (in_array($trigger_phid, $object_phids)) {
	return true;
	}
	}

	return false;
	}

	private function newRuleTranscript(HeraldRule $rule) {
	$xscript = id(new HeraldRuleTranscript())
	->setRuleID($rule->getID())
	->setRuleName($rule->getName())
	->setRuleOwner($rule->getAuthorPHID());

	$this->transcript->addRuleTranscript($xscript);

	return $xscript;
	}

	private function newConditionTranscript(
	HeraldRule $rule,
	HeraldCondition $condition) {

	$xscript = id(new HeraldConditionTranscript())
	->setRuleID($rule->getID())
	->setConditionID($condition->getID())
	->setFieldName($condition->getFieldName())
	->setCondition($condition->getFieldCondition())
	->setTestValue($condition->getValue());

	$this->transcript->addConditionTranscript($xscript);

	return $xscript;
	}

	private function newApplyTranscript(
	HeraldAdapter $adapter,
	HeraldRule $rule,
	HeraldActionRecord $action) {

	$effect = id(new HeraldEffect())
	->setObjectPHID($adapter->getPHID())
	->setAction($action->getAction())
	->setTarget($action->getTarget())
	->setRule($rule);

	$xscript = new HeraldApplyTranscript($effect, false);

	$this->transcript->addApplyTranscript($xscript);

	return $xscript;
	}

	private function isForbidden(
	HeraldRule $rule,
	HeraldAdapter $adapter) {

	$forbidden = $adapter->getForbiddenActions();
	if (!$forbidden) {
	return false;
	}

	$forbidden = array_fuse($forbidden);

	$is_forbidden = false;

	foreach ($rule->getConditions() as $condition) {
	$field_key = $condition->getFieldName();

	if (!isset($this->forbiddenFields[$field_key])) {
	$reason = null;

	try {
	$states = $adapter->getRequiredFieldStates($field_key);
	} catch (Exception $ex) {
	$states = array();
	}

	foreach ($states as $state) {
	if (!isset($forbidden[$state])) {
	continue;
	}
	$reason = $adapter->getForbiddenReason($state);
	break;
	}

	$this->forbiddenFields[$field_key] = $reason;
	}

	$forbidden_reason = $this->forbiddenFields[$field_key];
	if ($forbidden_reason !== null) {
	$this->newConditionTranscript($rule, $condition)
	->setResult(HeraldConditionTranscript::RESULT_FORBIDDEN)
	->setNote($forbidden_reason);

	$is_forbidden = true;
	}
	}

	foreach ($rule->getActions() as $action_record) {
	$action_key = $action_record->getAction();

	if (!isset($this->forbiddenActions[$action_key])) {
	$reason = null;

	try {
	$states = $adapter->getRequiredActionStates($action_key);
	} catch (Exception $ex) {
	$states = array();
	}

	foreach ($states as $state) {
	if (!isset($forbidden[$state])) {
	continue;
	}
	$reason = $adapter->getForbiddenReason($state);
	break;
	}

	$this->forbiddenActions[$action_key] = $reason;
	}

	$forbidden_reason = $this->forbiddenActions[$action_key];
	if ($forbidden_reason !== null) {
	$this->newApplyTranscript($adapter, $rule, $action_record)
	->setAppliedReason(
	array(
	array(
	'type' => HeraldAction::DO_STANDARD_FORBIDDEN,
	'data' => $forbidden_reason,
	),
	));

	$is_forbidden = true;
	}
	}

	return $is_forbidden;
	}

	}
	diff --git a/src/applications/herald/storage/HeraldRule.php b/src/applications/herald/storage/HeraldRule.php
	index 8fd1127eb7..44ef68ac03 100644
	--- a/src/applications/herald/storage/HeraldRule.php
	+++ b/src/applications/herald/storage/HeraldRule.php
	@@ -1,392 +1,400 @@
	<?php

	final class HeraldRule extends HeraldDAO
	implements
	PhabricatorApplicationTransactionInterface,
	PhabricatorFlaggableInterface,
	PhabricatorPolicyInterface,
	PhabricatorDestructibleInterface,
	PhabricatorSubscribableInterface {

	const TABLE_RULE_APPLIED = 'herald_ruleapplied';

	protected $name;
	protected $authorPHID;

	protected $contentType;
	protected $mustMatchAll;
	protected $repetitionPolicy;
	protected $ruleType;
	protected $isDisabled = 0;
	protected $triggerObjectPHID;

	protected $configVersion = 38;

	// PHIDs for which this rule has been applied
	private $ruleApplied = self::ATTACHABLE;
	private $validAuthor = self::ATTACHABLE;
	private $author = self::ATTACHABLE;
	private $conditions;
	private $actions;
	private $triggerObject = self::ATTACHABLE;

	const REPEAT_EVERY = 'every';
	const REPEAT_FIRST = 'first';
	+ const REPEAT_CHANGE = 'change';

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_COLUMN_SCHEMA => array(
	'name' => 'sort255',
	'contentType' => 'text255',
	'mustMatchAll' => 'bool',
	'configVersion' => 'uint32',
	'repetitionPolicy' => 'text32',
	'ruleType' => 'text32',
	'isDisabled' => 'uint32',
	'triggerObjectPHID' => 'phid?',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_name' => array(
	'columns' => array('name(128)'),
	),
	'key_author' => array(
	'columns' => array('authorPHID'),
	),
	'key_ruletype' => array(
	'columns' => array('ruleType'),
	),
	'key_trigger' => array(
	'columns' => array('triggerObjectPHID'),
	),
	),
	) + parent::getConfiguration();
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(HeraldRulePHIDType::TYPECONST);
	}

	public function getRuleApplied($phid) {
	return $this->assertAttachedKey($this->ruleApplied, $phid);
	}

	public function setRuleApplied($phid, $applied) {
	if ($this->ruleApplied === self::ATTACHABLE) {
	$this->ruleApplied = array();
	}
	$this->ruleApplied[$phid] = $applied;
	return $this;
	}

	public function loadConditions() {
	if (!$this->getID()) {
	return array();
	}
	return id(new HeraldCondition())->loadAllWhere(
	'ruleID = %d',
	$this->getID());
	}

	public function attachConditions(array $conditions) {
	assert_instances_of($conditions, 'HeraldCondition');
	$this->conditions = $conditions;
	return $this;
	}

	public function getConditions() {
	// TODO: validate conditions have been attached.
	return $this->conditions;
	}

	public function loadActions() {
	if (!$this->getID()) {
	return array();
	}
	return id(new HeraldActionRecord())->loadAllWhere(
	'ruleID = %d',
	$this->getID());
	}

	public function attachActions(array $actions) {
	// TODO: validate actions have been attached.
	assert_instances_of($actions, 'HeraldActionRecord');
	$this->actions = $actions;
	return $this;
	}

	public function getActions() {
	return $this->actions;
	}

	public function saveConditions(array $conditions) {
	assert_instances_of($conditions, 'HeraldCondition');
	return $this->saveChildren(
	id(new HeraldCondition())->getTableName(),
	$conditions);
	}

	public function saveActions(array $actions) {
	assert_instances_of($actions, 'HeraldActionRecord');
	return $this->saveChildren(
	id(new HeraldActionRecord())->getTableName(),
	$actions);
	}

	protected function saveChildren($table_name, array $children) {
	assert_instances_of($children, 'HeraldDAO');

	if (!$this->getID()) {
	throw new PhutilInvalidStateException('save');
	}

	foreach ($children as $child) {
	$child->setRuleID($this->getID());
	}

	$this->openTransaction();
	queryfx(
	$this->establishConnection('w'),
	'DELETE FROM %T WHERE ruleID = %d',
	$table_name,
	$this->getID());
	foreach ($children as $child) {
	$child->save();
	}
	$this->saveTransaction();
	}

	public function delete() {
	$this->openTransaction();
	queryfx(
	$this->establishConnection('w'),
	'DELETE FROM %T WHERE ruleID = %d',
	id(new HeraldCondition())->getTableName(),
	$this->getID());
	queryfx(
	$this->establishConnection('w'),
	'DELETE FROM %T WHERE ruleID = %d',
	id(new HeraldActionRecord())->getTableName(),
	$this->getID());
	$result = parent::delete();
	$this->saveTransaction();

	return $result;
	}

	public function hasValidAuthor() {
	return $this->assertAttached($this->validAuthor);
	}

	public function attachValidAuthor($valid) {
	$this->validAuthor = $valid;
	return $this;
	}

	public function getAuthor() {
	return $this->assertAttached($this->author);
	}

	public function attachAuthor(PhabricatorUser $user) {
	$this->author = $user;
	return $this;
	}

	public function isGlobalRule() {
	return ($this->getRuleType() === HeraldRuleTypeConfig::RULE_TYPE_GLOBAL);
	}

	public function isPersonalRule() {
	return ($this->getRuleType() === HeraldRuleTypeConfig::RULE_TYPE_PERSONAL);
	}

	public function isObjectRule() {
	return ($this->getRuleType() == HeraldRuleTypeConfig::RULE_TYPE_OBJECT);
	}

	public function attachTriggerObject($trigger_object) {
	$this->triggerObject = $trigger_object;
	return $this;
	}

	public function getTriggerObject() {
	return $this->assertAttached($this->triggerObject);
	}

	/**
	* Get a sortable key for rule execution order.
	*
	* Rules execute in a well-defined order: personal rules first, then object
	* rules, then global rules. Within each rule type, rules execute from lowest
	* ID to highest ID.
	*
	* This ordering allows more powerful rules (like global rules) to override
	* weaker rules (like personal rules) when multiple rules exist which try to
	* affect the same field. Executing from low IDs to high IDs makes
	* interactions easier to understand when adding new rules, because the newest
	* rules always happen last.
	*
	* @return string A sortable key for this rule.
	*/
	public function getRuleExecutionOrderSortKey() {

	$rule_type = $this->getRuleType();

	switch ($rule_type) {
	case HeraldRuleTypeConfig::RULE_TYPE_PERSONAL:
	$type_order = 1;
	break;
	case HeraldRuleTypeConfig::RULE_TYPE_OBJECT:
	$type_order = 2;
	break;
	case HeraldRuleTypeConfig::RULE_TYPE_GLOBAL:
	$type_order = 3;
	break;
	default:
	throw new Exception(pht('Unknown rule type "%s"!', $rule_type));
	}

	return sprintf('~%d%010d', $type_order, $this->getID());
	}

	public function getMonogram() {
	return 'H'.$this->getID();
	}


	/* -( Repetition Policies )------------------------------------------------ */


	public function getRepetitionPolicyStringConstant() {
	return $this->getRepetitionPolicy();
	}

	public function setRepetitionPolicyStringConstant($value) {
	$map = self::getRepetitionPolicyMap();

	if (!isset($map[$value])) {
	throw new Exception(
	pht(
	'Rule repetition string constant "%s" is unknown.',
	$value));
	}

	return $this->setRepetitionPolicy($value);
	}

	public function isRepeatEvery() {
	return ($this->getRepetitionPolicyStringConstant() === self::REPEAT_EVERY);
	}

	public function isRepeatFirst() {
	return ($this->getRepetitionPolicyStringConstant() === self::REPEAT_FIRST);
	}

	+ public function isRepeatOnChange() {
	+ return ($this->getRepetitionPolicyStringConstant() === self::REPEAT_CHANGE);
	+ }
	+
	public static function getRepetitionPolicySelectOptionMap() {
	$map = self::getRepetitionPolicyMap();
	return ipull($map, 'select');
	}

	private static function getRepetitionPolicyMap() {
	return array(
	self::REPEAT_EVERY => array(
	- 'select' => pht('every time'),
	+ 'select' => pht('every time this rule matches:'),
	),
	self::REPEAT_FIRST => array(
	- 'select' => pht('only the first time'),
	+ 'select' => pht('only the first time this rule matches:'),
	+ ),
	+ self::REPEAT_CHANGE => array(
	+ 'select' => pht('if this rule did not match the last time:'),
	),
	);
	}


	/* -( PhabricatorApplicationTransactionInterface )------------------------- */


	public function getApplicationTransactionEditor() {
	return new HeraldRuleEditor();
	}

	public function getApplicationTransactionObject() {
	return $this;
	}

	public function getApplicationTransactionTemplate() {
	return new HeraldRuleTransaction();
	}

	public function willRenderTimeline(
	PhabricatorApplicationTransactionView $timeline,
	AphrontRequest $request) {

	return $timeline;
	}


	/* -( PhabricatorPolicyInterface )----------------------------------------- */


	public function getCapabilities() {
	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	);
	}

	public function getPolicy($capability) {
	if ($capability == PhabricatorPolicyCapability::CAN_VIEW) {
	return PhabricatorPolicies::getMostOpenPolicy();
	}

	if ($this->isGlobalRule()) {
	$app = 'PhabricatorHeraldApplication';
	$herald = PhabricatorApplication::getByClass($app);
	$global = HeraldManageGlobalRulesCapability::CAPABILITY;
	return $herald->getPolicy($global);
	} else if ($this->isObjectRule()) {
	return $this->getTriggerObject()->getPolicy($capability);
	} else {
	return $this->getAuthorPHID();
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	return false;
	}

	public function describeAutomaticCapability($capability) {
	if ($capability == PhabricatorPolicyCapability::CAN_VIEW) {
	return null;
	}

	if ($this->isGlobalRule()) {
	return pht(
	'Global Herald rules can be edited by users with the "Can Manage '.
	'Global Rules" Herald application permission.');
	} else if ($this->isObjectRule()) {
	return pht('Object rules inherit the edit policies of their objects.');
	} else {
	return pht('A personal rule can only be edited by its owner.');
	}
	}


	/* -( PhabricatorSubscribableInterface )----------------------------------- */


	public function isAutomaticallySubscribed($phid) {
	return $this->isPersonalRule() && $phid == $this->getAuthorPHID();
	}


	/* -( PhabricatorDestructibleInterface )----------------------------------- */


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

	$this->openTransaction();
	$this->delete();
	$this->saveTransaction();
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Apr 29, 10:23 AM (1 d, 1 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 108289
Default Alt Text: (88 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions