Diffusion Phabricator (production) Browse

PhabricatorApplicationTransaction.php
f034fd80dbf7production

PhabricatorApplicationTransaction.php
View Options

			<?php

			abstract class PhabricatorApplicationTransaction
			extends PhabricatorLiskDAO
			implements PhabricatorPolicyInterface {

			const TARGET_TEXT = 'text';
			const TARGET_HTML = 'html';

			protected $phid;
			protected $objectPHID;
			protected $authorPHID;
			protected $viewPolicy;
			protected $editPolicy;

			protected $commentPHID;
			protected $commentVersion = 0;
			protected $transactionType;
			protected $oldValue;
			protected $newValue;
			protected $metadata = array();

			protected $contentSource;

			private $comment;
			private $commentNotLoaded;

			private $handles;
			private $renderingTarget = self::TARGET_HTML;
			private $transactionGroup = array();

			abstract public function getApplicationTransactionType();

			private function getApplicationObjectTypeName() {
			$types = PhabricatorPHIDType::getAllTypes();

			$type = idx($types, $this->getApplicationTransactionType());
			if ($type) {
			return $type->getTypeName();
			}

			return pht('Object');
			}

			public function getApplicationTransactionCommentObject() {
			throw new Exception("Not implemented!");
			}

			public function getApplicationTransactionViewObject() {
			return new PhabricatorApplicationTransactionView();
			}

			public function getMetadataValue($key, $default = null) {
			return idx($this->metadata, $key, $default);
			}

			public function setMetadataValue($key, $value) {
			$this->metadata[$key] = $value;
			return $this;
			}

			public function generatePHID() {
			$type = PhabricatorApplicationTransactionPHIDTypeTransaction::TYPECONST;
			$subtype = $this->getApplicationTransactionType();

			return PhabricatorPHID::generateNewPHID($type, $subtype);
			}

			public function getConfiguration() {
			return array(
			self::CONFIG_AUX_PHID => true,
			self::CONFIG_SERIALIZATION => array(
			'oldValue' => self::SERIALIZATION_JSON,
			'newValue' => self::SERIALIZATION_JSON,
			'metadata' => self::SERIALIZATION_JSON,
			),
			) + parent::getConfiguration();
			}

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

			public function getContentSource() {
			return PhabricatorContentSource::newFromSerialized($this->contentSource);
			}

			public function hasComment() {
			return $this->getComment() && strlen($this->getComment()->getContent());
			}

			public function getComment() {
			if ($this->commentNotLoaded) {
			throw new Exception("Comment for this transaction was not loaded.");
			}
			return $this->comment;
			}

			public function attachComment(
			PhabricatorApplicationTransactionComment $comment) {
			$this->comment = $comment;
			$this->commentNotLoaded = false;
			return $this;
			}

			public function setCommentNotLoaded($not_loaded) {
			$this->commentNotLoaded = $not_loaded;
			return $this;
			}

			/* -( Rendering )---------------------------------------------------------- */

			public function setRenderingTarget($rendering_target) {
			$this->renderingTarget = $rendering_target;
			return $this;
			}

			public function getRenderingTarget() {
			return $this->renderingTarget;
			}

			public function getRequiredHandlePHIDs() {
			$phids = array();

			$old = $this->getOldValue();
			$new = $this->getNewValue();

			$phids[] = array($this->getAuthorPHID());
			switch ($this->getTransactionType()) {
			case PhabricatorTransactions::TYPE_SUBSCRIBERS:
			$phids[] = $old;
			$phids[] = $new;
			break;
			case PhabricatorTransactions::TYPE_EDGE:
			$phids[] = ipull($old, 'dst');
			$phids[] = ipull($new, 'dst');
			break;
			case PhabricatorTransactions::TYPE_EDIT_POLICY:
			case PhabricatorTransactions::TYPE_VIEW_POLICY:
			if (!PhabricatorPolicyQuery::isGlobalPolicy($old)) {
			$phids[] = array($old);
			}
			if (!PhabricatorPolicyQuery::isGlobalPolicy($new)) {
			$phids[] = array($new);
			}
			break;
			}

			return array_mergev($phids);
			}

			public function setHandles(array $handles) {
			$this->handles = $handles;
			return $this;
			}

			public function getHandle($phid) {
			if (empty($this->handles[$phid])) {
			throw new Exception(
			"Transaction requires a handle ('{$phid}') it did not load.");
			}
			return $this->handles[$phid];
			}

			public function getHandleIfExists($phid) {
			return idx($this->handles, $phid);
			}

			public function getHandles() {
			if ($this->handles === null) {
			throw new Exception(
			'Transaction requires handles and it did not load them.'
			);
			}
			return $this->handles;
			}

			public function renderHandleLink($phid) {
			if ($this->renderingTarget == self::TARGET_HTML) {
			return $this->getHandle($phid)->renderLink();
			} else {
			return hsprintf('%s', $this->getHandle($phid)->getName());
			}
			}

			public function renderHandleList(array $phids) {
			$links = array();
			foreach ($phids as $phid) {
			$links[] = $this->renderHandleLink($phid);
			}
			return phutil_implode_html(', ', $links);
			}

			public function getIcon() {
			switch ($this->getTransactionType()) {
			case PhabricatorTransactions::TYPE_COMMENT:
			return 'comment';
			case PhabricatorTransactions::TYPE_SUBSCRIBERS:
			return 'message';
			case PhabricatorTransactions::TYPE_VIEW_POLICY:
			case PhabricatorTransactions::TYPE_EDIT_POLICY:
			return 'lock';
			case PhabricatorTransactions::TYPE_EDGE:
			return 'link';
			}

			return null;
			}

			public function getColor() {
			return null;
			}

			public function shouldHide() {
			switch ($this->getTransactionType()) {
			case PhabricatorTransactions::TYPE_VIEW_POLICY:
			case PhabricatorTransactions::TYPE_EDIT_POLICY:
			if ($this->getOldValue() === null) {
			return true;
			} else {
			return false;
			}
			break;
			}

			return false;
			}

			public function shouldHideForMail() {
			return $this->shouldHide();
			}

			public function getNoEffectDescription() {

			switch ($this->getTransactionType()) {
			case PhabricatorTransactions::TYPE_COMMENT:
			return pht('You can not post an empty comment.');
			case PhabricatorTransactions::TYPE_VIEW_POLICY:
			return pht(
			'This %s already has that view policy.',
			$this->getApplicationObjectTypeName());
			case PhabricatorTransactions::TYPE_EDIT_POLICY:
			return pht(
			'This %s already has that edit policy.',
			$this->getApplicationObjectTypeName());
			case PhabricatorTransactions::TYPE_SUBSCRIBERS:
			return pht(
			'All users are already subscribed to this %s.',
			$this->getApplicationObjectTypeName());
			case PhabricatorTransactions::TYPE_EDGE:
			return pht('Edges already exist; transaction has no effect.');
			}

			return pht('Transaction has no effect.');
			}

			public function getTitle() {
			$author_phid = $this->getAuthorPHID();

			$old = $this->getOldValue();
			$new = $this->getNewValue();

			switch ($this->getTransactionType()) {
			case PhabricatorTransactions::TYPE_COMMENT:
			return pht(
			'%s added a comment.',
			$this->renderHandleLink($author_phid));
			case PhabricatorTransactions::TYPE_VIEW_POLICY:
			return pht(
			'%s changed the visibility of this %s from "%s" to "%s".',
			$this->renderHandleLink($author_phid),
			$this->getApplicationObjectTypeName(),
			PhabricatorPolicy::newFromPolicyAndHandle(
			$old,
			$this->getHandleIfExists($old))->renderDescription(),
			PhabricatorPolicy::newFromPolicyAndHandle(
			$new,
			$this->getHandleIfExists($new))->renderDescription());
			case PhabricatorTransactions::TYPE_EDIT_POLICY:
			return pht(
			'%s changed the edit policy of this %s from "%s" to "%s".',
			$this->renderHandleLink($author_phid),
			$this->getApplicationObjectTypeName(),
			PhabricatorPolicy::newFromPolicyAndHandle(
			$old,
			$this->getHandleIfExists($old))->renderDescription(),
			PhabricatorPolicy::newFromPolicyAndHandle(
			$new,
			$this->getHandleIfExists($new))->renderDescription());
			case PhabricatorTransactions::TYPE_SUBSCRIBERS:
			$add = array_diff($new, $old);
			$rem = array_diff($old, $new);

			if ($add && $rem) {
			return pht(
			'%s edited subscriber(s), added %d: %s; removed %d: %s.',
			$this->renderHandleLink($author_phid),
			count($add),
			$this->renderHandleList($add),
			count($rem),
			$this->renderHandleList($rem));
			} else if ($add) {
			return pht(
			'%s added %d subscriber(s): %s.',
			$this->renderHandleLink($author_phid),
			count($add),
			$this->renderHandleList($add));
			} else {
			return pht(
			'%s removed %d subscriber(s): %s.',
			$this->renderHandleLink($author_phid),
			count($rem),
			$this->renderHandleList($rem));
			}
			break;
			case PhabricatorTransactions::TYPE_EDGE:
			$new = ipull($new, 'dst');
			$old = ipull($old, 'dst');
			$add = array_diff($new, $old);
			$rem = array_diff($old, $new);
			$type = $this->getMetadata('edge:type');
			$type = head($type);

			if ($add && $rem) {
			$string = PhabricatorEdgeConfig::getEditStringForEdgeType($type);
			return pht(
			$string,
			$this->renderHandleLink($author_phid),
			count($add),
			$this->renderHandleList($add),
			count($rem),
			$this->renderHandleList($rem));
			} else if ($add) {
			$string = PhabricatorEdgeConfig::getAddStringForEdgeType($type);
			return pht(
			$string,
			$this->renderHandleLink($author_phid),
			count($add),
			$this->renderHandleList($add));
			} else {
			$string = PhabricatorEdgeConfig::getRemoveStringForEdgeType($type);
			return pht(
			$string,
			$this->renderHandleLink($author_phid),
			count($rem),
			$this->renderHandleList($rem));
			}

			default:
			return pht(
			'%s edited this %s.',
			$this->renderHandleLink($author_phid),
			$this->getApplicationObjectTypeName());
			}
			}

			public function getTitleForFeed() {
			$author_phid = $this->getAuthorPHID();
			$object_phid = $this->getObjectPHID();

			$old = $this->getOldValue();
			$new = $this->getNewValue();

			switch ($this->getTransactionType()) {
			case PhabricatorTransactions::TYPE_COMMENT:
			return pht(
			'%s added a comment to %s.',
			$this->renderHandleLink($author_phid),
			$this->renderHandleLink($object_phid));
			case PhabricatorTransactions::TYPE_VIEW_POLICY:
			return pht(
			'%s changed the visibility for %s.',
			$this->renderHandleLink($author_phid),
			$this->renderHandleLink($object_phid));
			case PhabricatorTransactions::TYPE_EDIT_POLICY:
			return pht(
			'%s changed the edit policy for %s.',
			$this->renderHandleLink($author_phid),
			$this->renderHandleLink($object_phid));
			case PhabricatorTransactions::TYPE_SUBSCRIBERS:
			return pht(
			'%s updated subscribers of %s.',
			$this->renderHandleLink($author_phid),
			$this->renderHandleLink($object_phid));
			case PhabricatorTransactions::TYPE_EDGE:
			$type = $this->getMetadata('edge:type');
			$type = head($type);
			$string = PhabricatorEdgeConfig::getFeedStringForEdgeType($type);
			return pht(
			$string,
			$this->renderHandleLink($author_phid),
			$this->renderHandleLink($object_phid));
			}

			return $this->getTitle();
			}

			public function getBodyForFeed(PhabricatorFeedStory $story) {
			$old = $this->getOldValue();
			$new = $this->getNewValue();

			$body = null;

			switch ($this->getTransactionType()) {
			case PhabricatorTransactions::TYPE_COMMENT:
			$text = $this->getComment()->getContent();
			$body = phutil_escape_html_newlines(
			phutil_utf8_shorten($text, 128));
			break;
			}
			return $body;
			}

			public function getActionStrength() {
			switch ($this->getTransactionType()) {
			case PhabricatorTransactions::TYPE_COMMENT:
			return 0.5;
			}
			return 1.0;
			}

			public function getActionName() {
			switch ($this->getTransactionType()) {
			case PhabricatorTransactions::TYPE_COMMENT:
			return pht('Commented On');
			case PhabricatorTransactions::TYPE_VIEW_POLICY:
			case PhabricatorTransactions::TYPE_EDIT_POLICY:
			return pht('Changed Policy');
			case PhabricatorTransactions::TYPE_SUBSCRIBERS:
			return pht('Changed Subscribers');
			default:
			return pht('Updated');
			}
			}

			public function getMailTags() {
			return array();
			}

			public function hasChangeDetails() {
			return false;
			}

			public function renderChangeDetails(PhabricatorUser $viewer) {
			return null;
			}

			public function attachTransactionGroup(array $group) {
			assert_instances_of($group, 'PhabricatorApplicationTransaction');
			$this->transactionGroup = $group;
			return $this;
			}

			public function getTransactionGroup() {
			return $this->transactionGroup;
			}


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


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

			public function getPolicy($capability) {
			switch ($capability) {
			case PhabricatorPolicyCapability::CAN_VIEW:
			return $this->getViewPolicy();
			case PhabricatorPolicyCapability::CAN_EDIT:
			return $this->getEditPolicy();
			}
			}

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

			}

phab/src/applications/transactions/storage/PhabricatorApplicationTransaction.phpf034fd80dbf7production

PhabricatorApplicationTransaction.phpView Options

phab/src/applications/transactions/storage/PhabricatorApplicationTransaction.php
f034fd80dbf7production

PhabricatorApplicationTransaction.php
View Options