No OneTemporary
Actions

Size

39 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/herald/application/PhabricatorHeraldApplication.php b/src/applications/herald/application/PhabricatorHeraldApplication.php
	index e3537d9722..bef94b6ac4 100644
	--- a/src/applications/herald/application/PhabricatorHeraldApplication.php
	+++ b/src/applications/herald/application/PhabricatorHeraldApplication.php
	@@ -1,77 +1,77 @@
	<?php

	final class PhabricatorHeraldApplication extends PhabricatorApplication {

	public function getBaseURI() {
	return '/herald/';
	}

	public function getFontIcon() {
	return 'fa-bullhorn';
	}

	public function getName() {
	return pht('Herald');
	}

	public function getShortDescription() {
	return pht('Create Notification Rules');
	}

	public function getTitleGlyph() {
	return "\xE2\x98\xBF";
	}

	public function getHelpDocumentationArticles(PhabricatorUser $viewer) {
	return array(
	array(
	'name' => pht('Herald User Guide'),
	'href' => PhabricatorEnv::getDoclink('Herald User Guide'),
	),
	);
	}

	public function getFlavorText() {
	return pht('Watch for danger!');
	}

	public function getApplicationGroup() {
	return self::GROUP_UTILITIES;
	}

	public function getRemarkupRules() {
	return array(
	new HeraldRemarkupRule(),
	);
	}

	public function getRoutes() {
	return array(
	+ '/H(?P<id>[1-9]\d*)' => 'HeraldRuleViewController',
	'/herald/' => array(
	'(?:query/(?P<queryKey>[^/]+)/)?' => 'HeraldRuleListController',
	'new/' => 'HeraldNewController',
	- 'rule/(?P<id>[1-9]\d*)/' => 'HeraldRuleViewController',
	'edit/(?:(?P<id>[1-9]\d*)/)?' => 'HeraldRuleController',
	'disable/(?P<id>[1-9]\d*)/(?P<action>\w+)/'
	=> 'HeraldDisableController',
	'test/' => 'HeraldTestConsoleController',
	'transcript/' => array(
	'' => 'HeraldTranscriptListController',
	'(?:query/(?P<queryKey>[^/]+)/)?' => 'HeraldTranscriptListController',
	'(?P<id>[1-9]\d*)/'
	=> 'HeraldTranscriptController',
	),
	),
	);
	}

	protected function getCustomCapabilities() {
	return array(
	HeraldManageGlobalRulesCapability::CAPABILITY => array(
	'caption' => pht('Global rules can bypass access controls.'),
	'default' => PhabricatorPolicies::POLICY_ADMIN,
	),
	);
	}

	}
	diff --git a/src/applications/herald/controller/HeraldDisableController.php b/src/applications/herald/controller/HeraldDisableController.php
	index 054f30e7d3..bdbefa55ea 100644
	--- a/src/applications/herald/controller/HeraldDisableController.php
	+++ b/src/applications/herald/controller/HeraldDisableController.php
	@@ -1,66 +1,66 @@
	<?php

	final class HeraldDisableController extends HeraldController {

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

	$rule = id(new HeraldRuleQuery())
	->setViewer($viewer)
	->withIDs(array($id))
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->executeOne();
	if (!$rule) {
	return new Aphront404Response();
	}

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

	- $view_uri = $this->getApplicationURI("rule/{$id}/");
	+ $view_uri = '/'.$rule->getMonogram();

	$is_disable = ($action === 'disable');

	if ($request->isFormPost()) {
	$xaction = id(new HeraldRuleTransaction())
	->setTransactionType(HeraldRuleTransaction::TYPE_DISABLE)
	->setNewValue($is_disable);

	id(new HeraldRuleEditor())
	->setActor($viewer)
	->setContinueOnNoEffect(true)
	->setContentSourceFromRequest($request)
	->applyTransactions($rule, array($xaction));

	return id(new AphrontRedirectResponse())->setURI($view_uri);
	}

	if ($is_disable) {
	$title = pht('Really archive this rule?');
	$body = pht('This rule will no longer activate.');
	$button = pht('Archive Rule');
	} else {
	$title = pht('Really activate this rule?');
	$body = pht('This rule will become active again.');
	$button = pht('Activate Rule');
	}

	$dialog = id(new AphrontDialogView())
	->setUser($viewer)
	->setTitle($title)
	->appendChild($body)
	->addSubmitButton($button)
	->addCancelButton($view_uri);

	return id(new AphrontDialogResponse())->setDialog($dialog);
	}

	}
	diff --git a/src/applications/herald/controller/HeraldRuleController.php b/src/applications/herald/controller/HeraldRuleController.php
	index 37a583c7ef..510113b0de 100644
	--- a/src/applications/herald/controller/HeraldRuleController.php
	+++ b/src/applications/herald/controller/HeraldRuleController.php
	@@ -1,692 +1,692 @@
	<?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}/");
	+ $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 = $this->getApplicationURI("rule/{$id}/");
	+ $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 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);

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

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

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

	$serial_actions[] = array(
	$action->getAction(),
	$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'));
	}


	}
	diff --git a/src/applications/herald/controller/HeraldRuleViewController.php b/src/applications/herald/controller/HeraldRuleViewController.php
	index f6ec235a9e..2063ebcc2f 100644
	--- a/src/applications/herald/controller/HeraldRuleViewController.php
	+++ b/src/applications/herald/controller/HeraldRuleViewController.php
	@@ -1,156 +1,156 @@
	<?php

	final class HeraldRuleViewController extends HeraldController {

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

	$rule = id(new HeraldRuleQuery())
	->setViewer($viewer)
	->withIDs(array($id))
	->needConditionsAndActions(true)
	->executeOne();
	if (!$rule) {
	return new Aphront404Response();
	}

	$header = id(new PHUIHeaderView())
	->setUser($viewer)
	->setHeader($rule->getName())
	->setPolicyObject($rule);

	if ($rule->getIsDisabled()) {
	$header->setStatus(
	'fa-ban',
	'red',
	pht('Archived'));
	} else {
	$header->setStatus(
	'fa-check',
	'bluegrey',
	pht('Active'));
	}

	$actions = $this->buildActionView($rule);
	$properties = $this->buildPropertyView($rule, $actions);

	$id = $rule->getID();

	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->addTextCrumb("H{$id}");

	$object_box = id(new PHUIObjectBoxView())
	->setHeader($header)
	->addPropertyList($properties);

	$timeline = $this->buildTransactionTimeline(
	$rule,
	new HeraldTransactionQuery());
	$timeline->setShouldTerminate(true);

	return $this->buildApplicationPage(
	array(
	$crumbs,
	$object_box,
	$timeline,
	),
	array(
	'title' => $rule->getName(),
	));
	}

	private function buildActionView(HeraldRule $rule) {
	$viewer = $this->getRequest()->getUser();
	$id = $rule->getID();

	$view = id(new PhabricatorActionListView())
	->setUser($viewer)
	->setObject($rule)
	- ->setObjectURI($this->getApplicationURI("rule/{$id}/"));
	+ ->setObjectURI('/'.$rule->getMonogram());

	$can_edit = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	$rule,
	PhabricatorPolicyCapability::CAN_EDIT);

	$view->addAction(
	id(new PhabricatorActionView())
	->setName(pht('Edit Rule'))
	->setHref($this->getApplicationURI("edit/{$id}/"))
	->setIcon('fa-pencil')
	->setDisabled(!$can_edit)
	->setWorkflow(!$can_edit));

	if ($rule->getIsDisabled()) {
	$disable_uri = "disable/{$id}/enable/";
	$disable_icon = 'fa-check';
	$disable_name = pht('Activate Rule');
	} else {
	$disable_uri = "disable/{$id}/disable/";
	$disable_icon = 'fa-ban';
	$disable_name = pht('Archive Rule');
	}

	$view->addAction(
	id(new PhabricatorActionView())
	->setName(pht('Disable Rule'))
	->setHref($this->getApplicationURI($disable_uri))
	->setIcon($disable_icon)
	->setName($disable_name)
	->setDisabled(!$can_edit)
	->setWorkflow(true));

	return $view;
	}

	private function buildPropertyView(
	HeraldRule $rule,
	PhabricatorActionListView $actions) {

	$viewer = $this->getRequest()->getUser();

	$view = id(new PHUIPropertyListView())
	->setUser($viewer)
	->setObject($rule)
	->setActionList($actions);

	$view->addProperty(
	pht('Rule Type'),
	idx(HeraldRuleTypeConfig::getRuleTypeMap(), $rule->getRuleType()));

	if ($rule->isPersonalRule()) {
	$view->addProperty(
	pht('Author'),
	$viewer->renderHandle($rule->getAuthorPHID()));
	}

	$adapter = HeraldAdapter::getAdapterForContentType($rule->getContentType());
	if ($adapter) {
	$view->addProperty(
	pht('Applies To'),
	idx(
	HeraldAdapter::getEnabledAdapterMap($viewer),
	$rule->getContentType()));

	if ($rule->isObjectRule()) {
	$view->addProperty(
	pht('Trigger Object'),
	$viewer->renderHandle($rule->getTriggerObjectPHID()));
	}

	$view->invokeWillRenderEvent();

	$view->addSectionHeader(
	pht('Rule Description'),
	PHUIPropertyListView::ICON_SUMMARY);

	$handles = $viewer->loadHandles(HeraldAdapter::getHandlePHIDs($rule));
	$rule_text = $adapter->renderRuleAsText($rule, $handles, $viewer);
	$view->addTextContent($rule_text);
	}

	return $view;
	}

	}
	diff --git a/src/applications/herald/phid/HeraldRulePHIDType.php b/src/applications/herald/phid/HeraldRulePHIDType.php
	index f8d5c25db4..34c6d80c5f 100644
	--- a/src/applications/herald/phid/HeraldRulePHIDType.php
	+++ b/src/applications/herald/phid/HeraldRulePHIDType.php
	@@ -1,73 +1,73 @@
	<?php

	final class HeraldRulePHIDType extends PhabricatorPHIDType {

	const TYPECONST = 'HRUL';

	public function getTypeName() {
	return pht('Herald Rule');
	}

	public function newObject() {
	return new HeraldRule();
	}

	public function getPHIDTypeApplicationClass() {
	return 'PhabricatorHeraldApplication';
	}

	protected function buildQueryForObjects(
	PhabricatorObjectQuery $query,
	array $phids) {

	return id(new HeraldRuleQuery())
	->withPHIDs($phids);
	}

	public function loadHandles(
	PhabricatorHandleQuery $query,
	array $handles,
	array $objects) {

	foreach ($handles as $phid => $handle) {
	$rule = $objects[$phid];

	- $id = $rule->getID();
	- $name = $rule->getName();
	+ $monogram = $rule->getMonogram();
	+ $name = $rule->getName();

	- $handle->setName("H{$id}");
	- $handle->setFullName("H{$id} {$name}");
	- $handle->setURI("/herald/rule/{$id}/");
	+ $handle->setName($monogram);
	+ $handle->setFullName("{$monogram} {$name}");
	+ $handle->setURI("/{$monogram}");
	}
	}

	public function canLoadNamedObject($name) {
	return preg_match('/^H\d[1-9]\d$/i', $name);
	}

	public function loadNamedObjects(
	PhabricatorObjectQuery $query,
	array $names) {

	$id_map = array();
	foreach ($names as $name) {
	$id = (int)substr($name, 1);
	$id_map[$id][] = $name;
	}

	$objects = id(new HeraldRuleQuery())
	->setViewer($query->getViewer())
	->withIDs(array_keys($id_map))
	->execute();

	$results = array();
	foreach ($objects as $id => $object) {
	foreach (idx($id_map, $id, array()) as $name) {
	$results[$name] = $object;
	}
	}

	return $results;
	}

	}
	diff --git a/src/applications/herald/query/HeraldRuleSearchEngine.php b/src/applications/herald/query/HeraldRuleSearchEngine.php
	index 04b7a5d852..ad4c9a7ad2 100644
	--- a/src/applications/herald/query/HeraldRuleSearchEngine.php
	+++ b/src/applications/herald/query/HeraldRuleSearchEngine.php
	@@ -1,214 +1,214 @@
	<?php

	final class HeraldRuleSearchEngine extends PhabricatorApplicationSearchEngine {

	public function getResultTypeDescription() {
	return pht('Herald Rules');
	}

	public function getApplicationClassName() {
	return 'PhabricatorHeraldApplication';
	}

	public function buildSavedQueryFromRequest(AphrontRequest $request) {
	$saved = new PhabricatorSavedQuery();

	$saved->setParameter(
	'authorPHIDs',
	$this->readUsersFromRequest($request, 'authors'));

	$saved->setParameter('contentType', $request->getStr('contentType'));
	$saved->setParameter('ruleType', $request->getStr('ruleType'));
	$saved->setParameter(
	'disabled',
	$this->readBoolFromRequest($request, 'disabled'));

	return $saved;
	}

	public function buildQueryFromSavedQuery(PhabricatorSavedQuery $saved) {
	$query = id(new HeraldRuleQuery());

	$author_phids = $saved->getParameter('authorPHIDs');
	if ($author_phids) {
	$query->withAuthorPHIDs($author_phids);
	}

	$content_type = $saved->getParameter('contentType');
	$content_type = idx($this->getContentTypeValues(), $content_type);
	if ($content_type) {
	$query->withContentTypes(array($content_type));
	}

	$rule_type = $saved->getParameter('ruleType');
	$rule_type = idx($this->getRuleTypeValues(), $rule_type);
	if ($rule_type) {
	$query->withRuleTypes(array($rule_type));
	}

	$disabled = $saved->getParameter('disabled');
	if ($disabled !== null) {
	$query->withDisabled($disabled);
	}

	return $query;
	}

	public function buildSearchForm(
	AphrontFormView $form,
	PhabricatorSavedQuery $saved_query) {

	$author_phids = $saved_query->getParameter('authorPHIDs', array());
	$content_type = $saved_query->getParameter('contentType');
	$rule_type = $saved_query->getParameter('ruleType');

	$form
	->appendControl(
	id(new AphrontFormTokenizerControl())
	->setDatasource(new PhabricatorPeopleDatasource())
	->setName('authors')
	->setLabel(pht('Authors'))
	->setValue($author_phids))
	->appendChild(
	id(new AphrontFormSelectControl())
	->setName('contentType')
	->setLabel(pht('Content Type'))
	->setValue($content_type)
	->setOptions($this->getContentTypeOptions()))
	->appendChild(
	id(new AphrontFormSelectControl())
	->setName('ruleType')
	->setLabel(pht('Rule Type'))
	->setValue($rule_type)
	->setOptions($this->getRuleTypeOptions()))
	->appendChild(
	id(new AphrontFormSelectControl())
	->setName('disabled')
	->setLabel(pht('Rule Status'))
	->setValue($this->getBoolFromQuery($saved_query, 'disabled'))
	->setOptions(
	array(
	'' => pht('Show Enabled and Disabled Rules'),
	'false' => pht('Show Only Enabled Rules'),
	'true' => pht('Show Only Disabled Rules'),
	)));
	}

	protected function getURI($path) {
	return '/herald/'.$path;
	}

	protected function getBuiltinQueryNames() {
	$names = array();

	if ($this->requireViewer()->isLoggedIn()) {
	$names['authored'] = pht('Authored');
	}

	$names['active'] = pht('Active');
	$names['all'] = pht('All');

	return $names;
	}

	public function buildSavedQueryFromBuiltin($query_key) {
	$query = $this->newSavedQuery();
	$query->setQueryKey($query_key);

	$viewer_phid = $this->requireViewer()->getPHID();

	switch ($query_key) {
	case 'all':
	return $query;
	case 'active':
	return $query->setParameter('disabled', false);
	case 'authored':
	return $query
	->setParameter('authorPHIDs', array($viewer_phid))
	->setParameter('disabled', false);
	}

	return parent::buildSavedQueryFromBuiltin($query_key);
	}

	private function getContentTypeOptions() {
	return array(
	'' => pht('(All Content Types)'),
	) + HeraldAdapter::getEnabledAdapterMap($this->requireViewer());
	}

	private function getContentTypeValues() {
	return array_fuse(
	array_keys(
	HeraldAdapter::getEnabledAdapterMap($this->requireViewer())));
	}

	private function getRuleTypeOptions() {
	return array(
	'' => pht('(All Rule Types)'),
	) + HeraldRuleTypeConfig::getRuleTypeMap();
	}

	private function getRuleTypeValues() {
	return array_fuse(array_keys(HeraldRuleTypeConfig::getRuleTypeMap()));
	}

	protected function getRequiredHandlePHIDsForResultList(
	array $rules,
	PhabricatorSavedQuery $query) {

	return mpull($rules, 'getAuthorPHID');
	}

	protected function renderResultList(
	array $rules,
	PhabricatorSavedQuery $query,
	array $handles) {
	assert_instances_of($rules, 'HeraldRule');

	$viewer = $this->requireViewer();

	$content_type_map = HeraldAdapter::getEnabledAdapterMap($viewer);

	$list = id(new PHUIObjectItemListView())
	->setUser($viewer);
	foreach ($rules as $rule) {
	- $id = $rule->getID();
	+ $monogram = $rule->getMonogram();

	$item = id(new PHUIObjectItemView())
	- ->setObjectName("H{$id}")
	+ ->setObjectName($monogram)
	->setHeader($rule->getName())
	- ->setHref($this->getApplicationURI("rule/{$id}/"));
	+ ->setHref("/{$monogram}");

	if ($rule->isPersonalRule()) {
	$item->addIcon('fa-user', pht('Personal Rule'));
	$item->addByline(
	pht(
	'Authored by %s',
	$handles[$rule->getAuthorPHID()]->renderLink()));
	} else if ($rule->isObjectRule()) {
	$item->addIcon('fa-briefcase', pht('Object Rule'));
	} else {
	$item->addIcon('fa-globe', pht('Global Rule'));
	}

	if ($rule->getIsDisabled()) {
	$item->setDisabled(true);
	$item->addIcon('fa-lock grey', pht('Disabled'));
	}

	$content_type_name = idx($content_type_map, $rule->getContentType());
	$item->addAttribute(pht('Affects: %s', $content_type_name));

	$list->addItem($item);
	}

	$result = new PhabricatorApplicationSearchResultView();
	$result->setObjectList($list);
	$result->setNoDataString(pht('No rules found.'));

	return $result;

	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Wed, Apr 30, 5:33 PM (1 d, 2 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 108776
Default Alt Text: (39 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions