No OneTemporary
Actions

Size

26 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/herald/adapter/HeraldManiphestTaskAdapter.php b/src/applications/herald/adapter/HeraldManiphestTaskAdapter.php
	index aea6f10530..d4cbfcab2f 100644
	--- a/src/applications/herald/adapter/HeraldManiphestTaskAdapter.php
	+++ b/src/applications/herald/adapter/HeraldManiphestTaskAdapter.php
	@@ -1,188 +1,195 @@
	<?php

	/**
	* @group herald
	*/
	final class HeraldManiphestTaskAdapter extends HeraldAdapter {

	private $task;
	private $ccPHIDs = array();
	private $assignPHID;
	private $projectPHIDs = array();

	public function getAdapterApplicationClass() {
	return 'PhabricatorApplicationManiphest';
	}

	public function getAdapterContentDescription() {
	return pht(
	'React to tasks being created or updated.');
	}

	+ public function getRepetitionOptions() {
	+ return array(
	+ HeraldRepetitionPolicyConfig::EVERY,
	+ HeraldRepetitionPolicyConfig::FIRST,
	+ );
	+ }
	+
	public function supportsRuleType($rule_type) {
	switch ($rule_type) {
	case HeraldRuleTypeConfig::RULE_TYPE_GLOBAL:
	case HeraldRuleTypeConfig::RULE_TYPE_PERSONAL:
	return true;
	case HeraldRuleTypeConfig::RULE_TYPE_OBJECT:
	default:
	return false;
	}
	}

	public function setTask(ManiphestTask $task) {
	$this->task = $task;
	return $this;
	}
	public function getTask() {
	return $this->task;
	}

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

	private function setCcPHIDs(array $cc_phids) {
	$this->ccPHIDs = $cc_phids;
	return $this;
	}
	public function getCcPHIDs() {
	return $this->ccPHIDs;
	}

	public function setAssignPHID($assign_phid) {
	$this->assignPHID = $assign_phid;
	return $this;
	}
	public function getAssignPHID() {
	return $this->assignPHID;
	}

	public function setProjectPHIDs(array $project_phids) {
	$this->projectPHIDs = $project_phids;
	return $this;
	}
	public function getProjectPHIDs() {
	return $this->projectPHIDs;
	}

	public function getAdapterContentName() {
	return pht('Maniphest Tasks');
	}

	public function getFields() {
	return array_merge(
	array(
	self::FIELD_TITLE,
	self::FIELD_BODY,
	self::FIELD_AUTHOR,
	self::FIELD_ASSIGNEE,
	self::FIELD_CC,
	self::FIELD_CONTENT_SOURCE,
	self::FIELD_PROJECTS,
	self::FIELD_TASK_PRIORITY,
	self::FIELD_IS_NEW_OBJECT,
	),
	parent::getFields());
	}

	public function getActions($rule_type) {
	switch ($rule_type) {
	case HeraldRuleTypeConfig::RULE_TYPE_GLOBAL:
	return array(
	self::ACTION_ADD_CC,
	self::ACTION_ASSIGN_TASK,
	self::ACTION_ADD_PROJECTS,
	self::ACTION_NOTHING,
	);
	case HeraldRuleTypeConfig::RULE_TYPE_PERSONAL:
	return array(
	self::ACTION_ADD_CC,
	self::ACTION_FLAG,
	self::ACTION_ASSIGN_TASK,
	self::ACTION_NOTHING,
	);
	}
	}

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

	public function getHeraldName() {
	return 'T'.$this->getTask()->getID();
	}

	public function getHeraldField($field) {
	switch ($field) {
	case self::FIELD_TITLE:
	return $this->getTask()->getTitle();
	case self::FIELD_BODY:
	return $this->getTask()->getDescription();
	case self::FIELD_AUTHOR:
	return $this->getTask()->getAuthorPHID();
	case self::FIELD_ASSIGNEE:
	return $this->getTask()->getOwnerPHID();
	case self::FIELD_CC:
	return $this->getTask()->getCCPHIDs();
	case self::FIELD_PROJECTS:
	return $this->getTask()->getProjectPHIDs();
	case self::FIELD_TASK_PRIORITY:
	return $this->getTask()->getPriority();
	}

	return parent::getHeraldField($field);
	}

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

	$result = array();
	foreach ($effects as $effect) {
	$action = $effect->getAction();
	switch ($action) {
	case self::ACTION_NOTHING:
	$result[] = new HeraldApplyTranscript(
	$effect,
	true,
	pht('Great success at doing nothing.'));
	break;
	case self::ACTION_ADD_CC:
	foreach ($effect->getTarget() as $phid) {
	$this->ccPHIDs[] = $phid;
	}
	$result[] = new HeraldApplyTranscript(
	$effect,
	true,
	pht('Added address to cc list.'));
	break;
	case self::ACTION_FLAG:
	$result[] = parent::applyFlagEffect(
	$effect,
	$this->getTask()->getPHID());
	break;
	case self::ACTION_ASSIGN_TASK:
	$target_array = $effect->getTarget();
	$assign_phid = reset($target_array);
	$this->setAssignPHID($assign_phid);
	$result[] = new HeraldApplyTranscript(
	$effect,
	true,
	pht('Assigned task.'));
	break;
	case self::ACTION_ADD_PROJECTS:
	foreach ($effect->getTarget() as $phid) {
	$this->projectPHIDs[] = $phid;
	}
	$result[] = new HeraldApplyTranscript(
	$effect,
	true,
	pht('Added projects.'));
	break;
	default:
	throw new Exception("No rules to handle action '{$action}'.");
	}
	}
	return $result;
	}
	}
	diff --git a/src/applications/herald/engine/HeraldEngine.php b/src/applications/herald/engine/HeraldEngine.php
	index acc9556c97..5e62a8e19d 100644
	--- a/src/applications/herald/engine/HeraldEngine.php
	+++ b/src/applications/herald/engine/HeraldEngine.php
	@@ -1,434 +1,438 @@
	<?php

	final class HeraldEngine {

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

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

	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 = 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();
	+
	+ $policy_first = HeraldRepetitionPolicyConfig::FIRST;
	+ $policy_first_int = HeraldRepetitionPolicyConfig::toInt($policy_first);
	+ $is_first_only = ($rule->getRepetitionPolicy() == $policy_first_int);
	+
	try {
	if (!$this->getDryRun() &&
	- ($rule->getRepetitionPolicy() ==
	- HeraldRepetitionPolicyConfig::FIRST) &&
	+ $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.
	$xscript = id(new HeraldRuleTranscript())
	->setRuleID($rule->getID())
	->setResult(false)
	->setRuleName($rule->getName())
	->setRuleOwner($rule->getAuthorPHID())
	->setReason(
	"This rule is only supposed to be repeated a single time, ".
	"and it has already been applied.");
	$this->transcript->addRuleTranscript($xscript);
	$rule_matches = false;
	} else {
	$rule_matches = $this->doesRuleMatch($rule, $object);
	}
	} catch (HeraldRecursiveConditionsException $ex) {
	$names = array();
	foreach ($this->stack as $rule_id => $ignored) {
	$names[] = '"'.$rules[$rule_id]->getName().'"';
	}
	$names = implode(', ', $names);
	foreach ($this->stack as $rule_id => $ignored) {
	$xscript = new HeraldRuleTranscript();
	$xscript->setRuleID($rule_id);
	$xscript->setResult(false);
	$xscript->setReason(
	"Rules {$names} are recursively dependent upon one another! ".
	"Don't do this! You have formed an unresolvable cycle in the ".
	"dependency graph!");
	$xscript->setRuleName($rules[$rule_id]->getName());
	$xscript->setRuleOwner($rules[$rule_id]->getAuthorPHID());
	$this->transcript->addRuleTranscript($xscript);
	}
	$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();
	$first_policy = HeraldRepetitionPolicyConfig::toInt(
	HeraldRepetitionPolicyConfig::FIRST);

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

	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->getRepetitionPolicy() == $first_policy) {
	$applied_ids[] = $rule_id;
	}
	}

	if ($applied_ids) {
	$conn_w = id(new HeraldRule())->establishConnection('w');
	$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));
	}
	}

	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) {
	$match = $this->doesConditionMatch($rule, $condition, $object);

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

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

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

	$rule_transcript = new HeraldRuleTranscript();
	$rule_transcript->setRuleID($rule->getID());
	$rule_transcript->setResult($result);
	$rule_transcript->setReason($reason);
	$rule_transcript->setRuleName($rule->getName());
	$rule_transcript->setRuleOwner($rule->getAuthorPHID());

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

	return $result;
	}

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

	$object_value = $this->getConditionObjectValue($condition, $object);
	$test_value = $condition->getValue();

	$cond = $condition->getFieldCondition();

	$transcript = new HeraldConditionTranscript();
	$transcript->setRuleID($rule->getID());
	$transcript->setConditionID($condition->getID());
	$transcript->setFieldName($condition->getFieldName());
	$transcript->setCondition($cond);
	$transcript->setTestValue($test_value);

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

	$transcript->setResult($result);

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

	return $result;
	}

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

	$field = $condition->getFieldName();

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

	public function getObjectFieldValue($field) {
	if (isset($this->fieldCache[$field])) {
	return $this->fieldCache[$field];
	}

	$result = $this->object->getHeraldField($field);

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

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

	$effects = array();
	foreach ($rule->getActions() as $action) {
	$effect = new HeraldEffect();
	$effect->setObjectPHID($object->getPHID());
	$effect->setAction($action->getAction());
	$effect->setTarget($action->getTarget());

	$effect->setRuleID($rule->getID());
	$effect->setRulePHID($rule->getPHID());

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

	}
	diff --git a/src/applications/herald/storage/HeraldRule.php b/src/applications/herald/storage/HeraldRule.php
	index 81aa6125ba..7610935460 100644
	--- a/src/applications/herald/storage/HeraldRule.php
	+++ b/src/applications/herald/storage/HeraldRule.php
	@@ -1,253 +1,253 @@
	<?php

	final class HeraldRule extends HeraldDAO
	implements
	PhabricatorFlaggableInterface,
	PhabricatorPolicyInterface {

	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 = 30;
	+ protected $configVersion = 31;

	// 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;

	public function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	) + parent::getConfiguration();
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(HeraldPHIDTypeRule::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 HeraldAction())->loadAllWhere(
	'ruleID = %d',
	$this->getID());
	}

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

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

	public function loadEdits() {
	if (!$this->getID()) {
	return array();
	}
	$edits = id(new HeraldRuleEdit())->loadAllWhere(
	'ruleID = %d ORDER BY dateCreated DESC',
	$this->getID());

	return $edits;
	}

	public function logEdit($editor_phid, $action) {
	id(new HeraldRuleEdit())
	->setRuleID($this->getID())
	->setRuleName($this->getName())
	->setEditorPHID($editor_phid)
	->setAction($action)
	->save();
	}

	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, 'HeraldAction');
	return $this->saveChildren(
	id(new HeraldAction())->getTableName(),
	$actions);
	}

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

	if (!$this->getID()) {
	throw new Exception("Save rule before saving children.");
	}

	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 HeraldAction())->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);
	}


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


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

	public function getPolicy($capability) {
	if ($this->isGlobalRule()) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return PhabricatorPolicies::POLICY_USER;
	case PhabricatorPolicyCapability::CAN_EDIT:
	$app = 'PhabricatorApplicationHerald';
	$herald = PhabricatorApplication::getByClass($app);
	$global = HeraldCapabilityManageGlobalRules::CAPABILITY;
	return $herald->getPolicy($global);
	}
	} else if ($this->isObjectRule()) {
	return $this->getTriggerObject()->getPolicy($capability);
	} else {
	return PhabricatorPolicies::POLICY_NOONE;
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	if ($this->isPersonalRule()) {
	return ($viewer->getPHID() == $this->getAuthorPHID());
	} else {
	return false;
	}
	}

	public function describeAutomaticCapability($capability) {
	if ($this->isPersonalRule()) {
	return pht("A personal rule's owner can always view and edit it.");
	} else if ($this->isObjectRule()) {
	return pht("Object rules inherit the policies of their objects.");
	}

	return null;
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Jan 19, 15:56 (2 w, 6 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1126229
Default Alt Text: (26 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions