No OneTemporary
Actions

Size

64 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/herald/action/HeraldAction.php b/src/applications/herald/action/HeraldAction.php
	index bc47fee88b..02a9dfa60a 100644
	--- a/src/applications/herald/action/HeraldAction.php
	+++ b/src/applications/herald/action/HeraldAction.php
	@@ -1,390 +1,407 @@
	<?php

	abstract class HeraldAction extends Phobject {

	private $adapter;
	private $viewer;
	private $applyLog = array();

	const STANDARD_NONE = 'standard.none';
	const STANDARD_PHID_LIST = 'standard.phid.list';
	const STANDARD_TEXT = 'standard.text';

	const DO_STANDARD_EMPTY = 'do.standard.empty';
	const DO_STANDARD_NO_EFFECT = 'do.standard.no-effect';
	const DO_STANDARD_INVALID = 'do.standard.invalid';
	const DO_STANDARD_UNLOADABLE = 'do.standard.unloadable';
	const DO_STANDARD_PERMISSION = 'do.standard.permission';
	const DO_STANDARD_INVALID_ACTION = 'do.standard.invalid-action';
	const DO_STANDARD_WRONG_RULE_TYPE = 'do.standard.wrong-rule-type';

	abstract public function getHeraldActionName();
	abstract public function supportsObject($object);
	abstract public function supportsRuleType($rule_type);
	abstract public function applyEffect($object, HeraldEffect $effect);

	abstract public function renderActionDescription($value);

	protected function renderActionEffectDescription($type, $data) {
	return null;
	}

	public function getActionGroupKey() {
	return null;
	}

	public function getActionsForObject($object) {
	return array($this->getActionConstant() => $this);
	}

	protected function getDatasource() {
	throw new PhutilMethodNotImplementedException();
	}

	protected function getDatasourceValueMap() {
	return null;
	}

	public function getHeraldActionStandardType() {
	throw new PhutilMethodNotImplementedException();
	}

	public function getHeraldActionValueType() {
	switch ($this->getHeraldActionStandardType()) {
	case self::STANDARD_NONE:
	return new HeraldEmptyFieldValue();
	case self::STANDARD_TEXT:
	return new HeraldTextFieldValue();
	case self::STANDARD_PHID_LIST:
	$tokenizer = id(new HeraldTokenizerFieldValue())
	->setKey($this->getHeraldActionName())
	->setDatasource($this->getDatasource());

	$value_map = $this->getDatasourceValueMap();
	if ($value_map !== null) {
	$tokenizer->setValueMap($value_map);
	}

	return $tokenizer;
	}

	throw new PhutilMethodNotImplementedException();
	}

	public function willSaveActionValue($value) {
	try {
	$type = $this->getHeraldActionStandardType();
	} catch (PhutilMethodNotImplementedException $ex) {
	return $value;
	}

	switch ($type) {
	case self::STANDARD_PHID_LIST:
	return array_keys($value);
	}

	return $value;
	}

	+ public function getEditorValue(PhabricatorUser $viewer, $target) {
	+ try {
	+ $type = $this->getHeraldActionStandardType();
	+ } catch (PhutilMethodNotImplementedException $ex) {
	+ return $target;
	+ }
	+
	+ switch ($type) {
	+ case self::STANDARD_PHID_LIST:
	+ $handles = $viewer->loadHandles($target);
	+ $handles = iterator_to_array($handles);
	+ return mpull($handles, 'getName', 'getPHID');
	+ }
	+
	+ return $target;
	+ }
	+
	final public function setAdapter(HeraldAdapter $adapter) {
	$this->adapter = $adapter;
	return $this;
	}

	final public function getAdapter() {
	return $this->adapter;
	}

	final public function setViewer(PhabricatorUser $viewer) {
	$this->viewer = $viewer;
	return $this;
	}

	final public function getViewer() {
	return $this->viewer;
	}

	final public function getActionConstant() {
	$class = new ReflectionClass($this);

	$const = $class->getConstant('ACTIONCONST');
	if ($const === false) {
	throw new Exception(
	pht(
	'"%s" class "%s" must define a "%s" property.',
	__CLASS__,
	get_class($this),
	'ACTIONCONST'));
	}

	$limit = self::getActionConstantByteLimit();
	if (!is_string($const) \|\| (strlen($const) > $limit)) {
	throw new Exception(
	pht(
	'"%s" class "%s" has an invalid "%s" property. Action constants '.
	'must be strings and no more than %s bytes in length.',
	__CLASS__,
	get_class($this),
	'ACTIONCONST',
	new PhutilNumber($limit)));
	}

	return $const;
	}

	final public static function getActionConstantByteLimit() {
	return 64;
	}

	final public static function getAllActions() {
	return id(new PhutilClassMapQuery())
	->setAncestorClass(__CLASS__)
	->setUniqueMethod('getActionConstant')
	->execute();
	}

	protected function logEffect($type, $data = null) {
	if (!is_string($type)) {
	throw new Exception(
	pht(
	'Effect type passed to "%s" must be a scalar string.',
	'logEffect()'));
	}

	$this->applyLog[] = array(
	'type' => $type,
	'data' => $data,
	);

	return $this;
	}

	final public function getApplyTranscript(HeraldEffect $effect) {
	$context = $this->applyLog;
	$this->applyLog = array();
	return new HeraldApplyTranscript($effect, true, $context);
	}

	protected function getActionEffectMap() {
	throw new PhutilMethodNotImplementedException();
	}

	private function getActionEffectSpec($type) {
	$map = $this->getActionEffectMap() + $this->getStandardEffectMap();
	return idx($map, $type, array());
	}

	final public function renderActionEffectIcon($type, $data) {
	$map = $this->getActionEffectSpec($type);
	return idx($map, 'icon');
	}

	final public function renderActionEffectColor($type, $data) {
	$map = $this->getActionEffectSpec($type);
	return idx($map, 'color');
	}

	final public function renderActionEffectName($type, $data) {
	$map = $this->getActionEffectSpec($type);
	return idx($map, 'name');
	}

	protected function renderHandleList($phids) {
	if (!is_array($phids)) {
	return pht('(Invalid List)');
	}

	return $this->getViewer()
	->renderHandleList($phids)
	->setAsInline(true)
	->render();
	}

	protected function loadStandardTargets(
	array $phids,
	array $allowed_types,
	array $current_value) {

	$phids = array_fuse($phids);
	if (!$phids) {
	$this->logEffect(self::DO_STANDARD_EMPTY);
	}

	$current_value = array_fuse($current_value);
	$no_effect = array();
	foreach ($phids as $phid) {
	if (isset($current_value[$phid])) {
	$no_effect[] = $phid;
	unset($phids[$phid]);
	}
	}

	if ($no_effect) {
	$this->logEffect(self::DO_STANDARD_NO_EFFECT, $no_effect);
	}

	if (!$phids) {
	return;
	}

	$allowed_types = array_fuse($allowed_types);
	$invalid = array();
	foreach ($phids as $phid) {
	$type = phid_get_type($phid);
	if ($type == PhabricatorPHIDConstants::PHID_TYPE_UNKNOWN) {
	$invalid[] = $phid;
	unset($phids[$phid]);
	continue;
	}

	if ($allowed_types && empty($allowed_types[$type])) {
	$invalid[] = $phid;
	unset($phids[$phid]);
	continue;
	}
	}

	if ($invalid) {
	$this->logEffect(self::DO_STANDARD_INVALID, $invalid);
	}

	if (!$phids) {
	return;
	}

	$targets = id(new PhabricatorObjectQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPHIDs($phids)
	->execute();
	$targets = mpull($targets, null, 'getPHID');

	$unloadable = array();
	foreach ($phids as $phid) {
	if (empty($targets[$phid])) {
	$unloadable[] = $phid;
	unset($phids[$phid]);
	}
	}

	if ($unloadable) {
	$this->logEffect(self::DO_STANDARD_UNLOADABLE, $unloadable);
	}

	if (!$phids) {
	return;
	}

	$adapter = $this->getAdapter();
	$object = $adapter->getObject();

	if ($object instanceof PhabricatorPolicyInterface) {
	$no_permission = array();
	foreach ($targets as $phid => $target) {
	if (!($target instanceof PhabricatorUser)) {
	continue;
	}

	$can_view = PhabricatorPolicyFilter::hasCapability(
	$target,
	$object,
	PhabricatorPolicyCapability::CAN_VIEW);
	if ($can_view) {
	continue;
	}

	$no_permission[] = $phid;
	unset($targets[$phid]);
	}
	}

	if ($no_permission) {
	$this->logEffect(self::DO_STANDARD_PERMISSION, $no_permission);
	}

	return $targets;
	}

	protected function getStandardEffectMap() {
	return array(
	self::DO_STANDARD_EMPTY => array(
	'icon' => 'fa-ban',
	'color' => 'grey',
	'name' => pht('No Targets'),
	),
	self::DO_STANDARD_NO_EFFECT => array(
	'icon' => 'fa-circle-o',
	'color' => 'grey',
	'name' => pht('No Effect'),
	),
	self::DO_STANDARD_INVALID => array(
	'icon' => 'fa-ban',
	'color' => 'red',
	'name' => pht('Invalid Targets'),
	),
	self::DO_STANDARD_UNLOADABLE => array(
	'icon' => 'fa-ban',
	'color' => 'red',
	'name' => pht('Unloadable Targets'),
	),
	self::DO_STANDARD_PERMISSION => array(
	'icon' => 'fa-lock',
	'color' => 'red',
	'name' => pht('No Permission'),
	),
	self::DO_STANDARD_INVALID_ACTION => array(
	'icon' => 'fa-ban',
	'color' => 'red',
	'name' => pht('Invalid Action'),
	),
	self::DO_STANDARD_WRONG_RULE_TYPE => array(
	'icon' => 'fa-ban',
	'color' => 'red',
	'name' => pht('Wrong Rule Type'),
	),
	);
	}

	final public function renderEffectDescription($type, $data) {
	$result = $this->renderActionEffectDescription($type, $data);
	if ($result !== null) {
	return $result;
	}

	switch ($type) {
	case self::DO_STANDARD_EMPTY:
	return pht(
	'This action specifies no targets.');
	case self::DO_STANDARD_NO_EFFECT:
	return pht(
	'This action has no effect on %s target(s): %s.',
	new PhutilNumber(count($data)),
	$this->renderHandleList($data));
	case self::DO_STANDARD_INVALID:
	return pht(
	'%s target(s) are invalid or of the wrong type: %s.',
	new PhutilNumber(count($data)),
	$this->renderHandleList($data));
	case self::DO_STANDARD_UNLOADABLE:
	return pht(
	'%s target(s) could not be loaded: %s.',
	new PhutilNumber(count($data)),
	$this->renderHandleList($data));
	case self::DO_STANDARD_PERMISSION:
	return pht(
	'%s target(s) do not have permission to see this object: %s.',
	new PhutilNumber(count($data)),
	$this->renderHandleList($data));
	case self::DO_STANDARD_INVALID_ACTION:
	return pht(
	'No implementation is available for rule "%s".',
	$data);
	case self::DO_STANDARD_WRONG_RULE_TYPE:
	return pht(
	'This action does not support rules of type "%s".',
	$data);
	}

	return null;
	}

	}
	diff --git a/src/applications/herald/adapter/HeraldAdapter.php b/src/applications/herald/adapter/HeraldAdapter.php
	index b46e9430c1..bec6677230 100644
	--- a/src/applications/herald/adapter/HeraldAdapter.php
	+++ b/src/applications/herald/adapter/HeraldAdapter.php
	@@ -1,1051 +1,1061 @@
	<?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_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 $queuedTransactions = array();
	private $emailPHIDs = array();
	private $forcedEmailPHIDs = array();
	private $fieldMap;
	private $actionMap;
	private $edgeCache = 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);
	}

	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 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_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:
	// "Contains" can take an array of strings, as in "Any changed
	// filename" for diffs.
	foreach ((array)$field_value as $value) {
	if (stripos($value, $condition_value) !== false) {
	return true;
	}
	}
	return false;
	case self::CONDITION_NOT_CONTAINS:
	return (stripos($field_value, $condition_value) === false);
	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:
	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 true;
	}
	}
	return false;
	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:
	$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() {
	return array(
	HeraldRepetitionPolicyConfig::EVERY,
	);
	}

	abstract protected function initializeNewAdapter();

	/**
	* 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,
	- array $handles) {
	+ 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())
	->setIconFont('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),
	));
	}

	$integer_code_for_every = HeraldRepetitionPolicyConfig::toInt(
	HeraldRepetitionPolicyConfig::EVERY);

	if ($rule->getRepetitionPolicy() == $integer_code_for_every) {
	$action_text =
	pht('Take these actions every time this rule matches:');
	} else {
	$action_text =
	pht('Take these actions the first 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];
	}

	}
	diff --git a/src/applications/herald/controller/HeraldRuleController.php b/src/applications/herald/controller/HeraldRuleController.php
	index cd35307723..ce7a46cd00 100644
	--- a/src/applications/herald/controller/HeraldRuleController.php
	+++ b/src/applications/herald/controller/HeraldRuleController.php
	@@ -1,682 +1,668 @@
	<?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 = $this->getApplicationURI("rule/{$id}/");
	} else {
	$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])) {
	$rule_type = HeraldRuleTypeConfig::RULE_TYPE_PERSONAL;
	}
	$rule->setRuleType($rule_type);

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

	if (!$adapter->supportsRuleType($rule->getRuleType())) {
	throw new Exception(
	pht(
	"This rule's content type does not support the selected rule ".
	"type."));
	}

	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 = $this->getApplicationURI("rule/{$id}/");
	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 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 green',
	'sigil' => 'create-action',
	'mustcapture' => true,
	),
	pht('New Action')))
	->setDescription(pht(
	'Take these actions %s this rule matches:',
	$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')
	: pht('Create Herald Rule');

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

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

	return $this->buildApplicationPage(
	array(
	$crumbs,
	$form_box,
	),
	array(
	'title' => pht('Edit Rule'),
	));
	}

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

	$repetition_policy_param = $request->getStr('repetition_policy');
	$rule->setRepetitionPolicy(
	HeraldRepetitionPolicyConfig::toInt($repetition_policy_param));

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

	if (!strlen($rule->getName())) {
	$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;
	}

	$rule->attachConditions($conditions);
	$rule->attachActions($actions);

	if (!$errors) {
	$edit_action = $rule->getID() ? 'edit' : 'create';

	$rule->openTransaction();
	$rule->save();
	$rule->saveConditions($conditions);
	$rule->saveActions($actions);
	$rule->saveTransaction();
	}

	return array($e_name, $errors);
	}

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

	$serial_conditions = array(
	array('default', 'default', ''),
	);

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

	$serial_conditions[] = array(
	$condition->getFieldName(),
	$condition->getFieldCondition(),
	$value,
	);
	}
	}

	$serial_actions = array(
	array('default', ''),
	);

	if ($rule->getActions()) {
	$serial_actions = array();
	foreach ($rule->getActions() as $action) {
	- switch ($action->getAction()) {
	- case HeraldAdapter::ACTION_BLOCK:
	- $current_value = $action->getTarget();
	- break;
	- default:
	- if (is_array($action->getTarget())) {
	- $target_map = array();
	- foreach ((array)$action->getTarget() as $fbid) {
	- $target_map[$fbid] = $handles[$fbid]->getName();
	- }
	- $current_value = $target_map;
	- } else {
	- $current_value = $action->getTarget();
	- }
	- break;
	- }
	+ $value = $adapter->getEditorValueForAction(
	+ $this->getViewer(),
	+ $action);

	$serial_actions[] = array(
	$action->getAction(),
	- $current_value,
	+ $value,
	);
	}
	}

	$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;
	}

	Javelin::initBehavior(
	'herald-rule-editor',
	array(
	'root' => 'herald-rule-edit-form',
	'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 = HeraldRepetitionPolicyConfig::toString(
	$rule->getRepetitionPolicy());

	$repetition_options = $adapter->getRepetitionOptions();
	$repetition_names = HeraldRepetitionPolicyConfig::getMap();
	$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'));
	}


	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jul 3, 8:42 PM (47 m, 56 s)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 166381
Default Alt Text: (64 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions