No OneTemporary
Actions

Size

63 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/resources/sql/patches/20130801.pastexactions.php b/resources/sql/patches/20130801.pastexactions.php
	index b04edddda5..1f48d99784 100644
	--- a/resources/sql/patches/20130801.pastexactions.php
	+++ b/resources/sql/patches/20130801.pastexactions.php
	@@ -1,48 +1,48 @@
	<?php

	$table = new PhabricatorPaste();
	$x_table = new PhabricatorPasteTransaction();

	$conn_w = $table->establishConnection('w');
	$conn_w->openTransaction();

	echo "Adding transactions for existing paste objects...\n";

	$rows = new LiskRawMigrationIterator($conn_w, 'pastebin_paste');
	foreach ($rows as $row) {

	$id = $row['id'];
	echo "Adding transactions for paste id {$id}...\n";

	$xaction_phid = PhabricatorPHID::generateNewPHID(
	PhabricatorApplicationTransactionPHIDTypeTransaction::TYPECONST);

	queryfx(
	$conn_w,
	'INSERT INTO %T (phid, authorPHID, objectPHID, viewPolicy, editPolicy,
	transactionType, oldValue, newValue,
	contentSource, metadata, dateCreated, dateModified,
	commentVersion)
	VALUES (%s, %s, %s, %s, %s, %s, %ns, %ns, %s, %s, %d, %d, %d)',
	$x_table->getTableName(),
	$xaction_phid,
	$row['authorPHID'],
	$row['phid'],
	'public',
	$row['authorPHID'],
	- PhabricatorPasteTransaction::TYPE_CREATE,
	+ PhabricatorPasteTransaction::TYPE_CONTENT,
	'null',
	$row['filePHID'],
	PhabricatorContentSource::newForSource(
	PhabricatorContentSource::SOURCE_LEGACY,
	array())->serialize(),
	'[]',
	$row['dateCreated'],
	$row['dateCreated'],
	0);

	}

	$conn_w->saveTransaction();

	echo "Done.\n";
	diff --git a/src/applications/paste/conduit/ConduitAPI_paste_create_Method.php b/src/applications/paste/conduit/ConduitAPI_paste_create_Method.php
	index a2d08ecd24..f09f650db1 100644
	--- a/src/applications/paste/conduit/ConduitAPI_paste_create_Method.php
	+++ b/src/applications/paste/conduit/ConduitAPI_paste_create_Method.php
	@@ -1,75 +1,75 @@
	<?php

	/**
	* @group conduit
	*/
	final class ConduitAPI_paste_create_Method extends ConduitAPI_paste_Method {

	public function getMethodDescription() {
	return 'Create a new paste.';
	}

	public function defineParamTypes() {
	return array(
	'content' => 'required string',
	'title' => 'optional string',
	'language' => 'optional string',
	);
	}

	public function defineReturnType() {
	return 'nonempty dict';
	}

	public function defineErrorTypes() {
	return array(
	'ERR-NO-PASTE' => 'Paste may not be empty.',
	);
	}

	protected function execute(ConduitAPIRequest $request) {
	$content = $request->getValue('content');
	$title = $request->getValue('title');
	$language = $request->getValue('language');

	if (!strlen($content)) {
	throw new ConduitException('ERR-NO-PASTE');
	}

	$title = nonempty($title, 'Masterwork From Distant Lands');
	$language = nonempty($language, '');

	$viewer = $request->getUser();

	$paste = PhabricatorPaste::initializeNewPaste($viewer);

	$file = PhabricatorPasteEditor::initializeFileForPaste(
	$viewer,
	$title,
	$content);

	$xactions = array();

	$xactions[] = id(new PhabricatorPasteTransaction())
	- ->setTransactionType(PhabricatorPasteTransaction::TYPE_CREATE)
	+ ->setTransactionType(PhabricatorPasteTransaction::TYPE_CONTENT)
	->setNewValue($file->getPHID());

	$xactions[] = id(new PhabricatorPasteTransaction())
	->setTransactionType(PhabricatorPasteTransaction::TYPE_TITLE)
	->setNewValue($title);

	$xactions[] = id(new PhabricatorPasteTransaction())
	->setTransactionType(PhabricatorPasteTransaction::TYPE_LANGUAGE)
	->setNewValue($language);

	$editor = id(new PhabricatorPasteEditor())
	->setActor($viewer)
	->setContentSourceFromConduitRequest($request);

	$xactions = $editor->applyTransactions($paste, $xactions);

	$paste->attachRawContent($content);
	return $this->buildPasteInfoDictionary($paste);
	}

	}
	diff --git a/src/applications/paste/controller/PhabricatorPasteEditController.php b/src/applications/paste/controller/PhabricatorPasteEditController.php
	index 61dd106af1..76df630b20 100644
	--- a/src/applications/paste/controller/PhabricatorPasteEditController.php
	+++ b/src/applications/paste/controller/PhabricatorPasteEditController.php
	@@ -1,227 +1,211 @@
	<?php

	/**
	* @group paste
	*/
	final class PhabricatorPasteEditController extends PhabricatorPasteController {

	private $id;

	public function willProcessRequest(array $data) {
	$this->id = idx($data, 'id');
	}


	public function processRequest() {
	$request = $this->getRequest();
	$user = $request->getUser();

	$parent = null;
	$parent_id = null;
	if (!$this->id) {
	$is_create = true;

	$paste = PhabricatorPaste::initializeNewPaste($user);

	$parent_id = $request->getStr('parent');
	if ($parent_id) {
	// NOTE: If the Paste is forked from a paste which the user no longer
	// has permission to see, we still let them edit it.
	$parent = id(new PhabricatorPasteQuery())
	->setViewer($user)
	->withIDs(array($parent_id))
	->needContent(true)
	->needRawContent(true)
	->execute();
	$parent = head($parent);

	if ($parent) {
	$paste->setParentPHID($parent->getPHID());
	$paste->setViewPolicy($parent->getViewPolicy());
	}
	}

	$paste->setAuthorPHID($user->getPHID());
	+ $paste->attachRawContent('');
	} else {
	$is_create = false;

	$paste = id(new PhabricatorPasteQuery())
	->setViewer($user)
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->withIDs(array($this->id))
	+ ->needRawContent(true)
	->executeOne();
	if (!$paste) {
	return new Aphront404Response();
	}
	}

	$text = null;
	$e_text = true;
	$errors = array();
	if ($is_create && $parent) {
	$v_title = pht('Fork of %s', $parent->getFullName());
	$v_language = $parent->getLanguage();
	$v_text = $parent->getRawContent();
	} else {
	$v_title = $paste->getTitle();
	$v_language = $paste->getLanguage();
	- $v_text = '';
	+ $v_text = $paste->getRawContent();
	}
	$v_policy = $paste->getViewPolicy();

	if ($request->isFormPost()) {
	$xactions = array();

	- if ($is_create) {
	- $v_text = $request->getStr('text');
	- if (!strlen($v_text)) {
	- $e_text = pht('Required');
	- $errors[] = pht('The paste may not be blank.');
	- } else {
	- $e_text = null;
	- }
	- }
	+ $v_text = $request->getStr('text');
	+ if (!strlen($v_text)) {
	+ $e_text = pht('Required');
	+ $errors[] = pht('The paste may not be blank.');
	+ } else {
	+ $e_text = null;
	+ }

	$v_title = $request->getStr('title');
	$v_language = $request->getStr('language');
	$v_policy = $request->getStr('can_view');

	// NOTE: The author is the only editor and can always view the paste,
	// so it's impossible for them to choose an invalid policy.

	if (!$errors) {
	- if ($is_create) {
	+ if ($is_create \|\| ($v_text !== $paste->getRawContent())) {
	$file = PhabricatorPasteEditor::initializeFileForPaste(
	$user,
	$v_title,
	$v_text);

	$xactions[] = id(new PhabricatorPasteTransaction())
	- ->setTransactionType(PhabricatorPasteTransaction::TYPE_CREATE)
	+ ->setTransactionType(PhabricatorPasteTransaction::TYPE_CONTENT)
	->setNewValue($file->getPHID());
	}

	$xactions[] = id(new PhabricatorPasteTransaction())
	->setTransactionType(PhabricatorPasteTransaction::TYPE_TITLE)
	->setNewValue($v_title);
	$xactions[] = id(new PhabricatorPasteTransaction())
	->setTransactionType(PhabricatorPasteTransaction::TYPE_LANGUAGE)
	->setNewValue($v_language);
	$xactions[] = id(new PhabricatorPasteTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_VIEW_POLICY)
	->setNewValue($v_policy);
	$editor = id(new PhabricatorPasteEditor())
	->setActor($user)
	->setContentSourceFromRequest($request)
	->setContinueOnNoEffect(true);
	$xactions = $editor->applyTransactions($paste, $xactions);
	return id(new AphrontRedirectResponse())->setURI($paste->getURI());
	} else {
	// make sure we update policy so its correctly populated to what
	// the user chose
	$paste->setViewPolicy($v_policy);
	}
	}

	$form = new AphrontFormView();

	$langs = array(
	'' => pht('(Detect From Filename in Title)'),
	) + PhabricatorEnv::getEnvConfig('pygments.dropdown-choices');

	$form
	->setUser($user)
	->addHiddenInput('parent', $parent_id)
	->appendChild(
	id(new AphrontFormTextControl())
	->setLabel(pht('Title'))
	->setValue($v_title)
	->setName('title'))
	->appendChild(
	id(new AphrontFormSelectControl())
	->setLabel(pht('Language'))
	->setName('language')
	->setValue($v_language)
	->setOptions($langs));

	$policies = id(new PhabricatorPolicyQuery())
	->setViewer($user)
	->setObject($paste)
	->execute();

	$form->appendChild(
	id(new AphrontFormPolicyControl())
	->setUser($user)
	->setCapability(PhabricatorPolicyCapability::CAN_VIEW)
	->setPolicyObject($paste)
	->setPolicies($policies)
	->setName('can_view'));

	- if ($is_create) {
	- $form
	- ->appendChild(
	- id(new AphrontFormTextAreaControl())
	- ->setLabel(pht('Text'))
	- ->setError($e_text)
	- ->setValue($v_text)
	- ->setHeight(AphrontFormTextAreaControl::HEIGHT_VERY_TALL)
	- ->setCustomClass('PhabricatorMonospaced')
	- ->setName('text'));
	- } else {
	- $fork_link = phutil_tag(
	- 'a',
	- array(
	- 'href' => $this->getApplicationURI('?parent='.$paste->getID())
	- ),
	- pht('Fork'));
	- $form
	- ->appendChild(
	- id(new AphrontFormMarkupControl())
	+ $form
	+ ->appendChild(
	+ id(new AphrontFormTextAreaControl())
	->setLabel(pht('Text'))
	- ->setValue(pht(
	- 'Paste text can not be edited. %s to create a new paste.',
	- $fork_link)));
	- }
	+ ->setError($e_text)
	+ ->setValue($v_text)
	+ ->setHeight(AphrontFormTextAreaControl::HEIGHT_VERY_TALL)
	+ ->setCustomClass('PhabricatorMonospaced')
	+ ->setName('text'));

	$submit = new AphrontFormSubmitControl();

	if (!$is_create) {
	$submit->addCancelButton($paste->getURI());
	$submit->setValue(pht('Save Paste'));
	$title = pht('Edit %s', $paste->getFullName());
	$short = pht('Edit');
	} else {
	$submit->setValue(pht('Create Paste'));
	$title = pht('Create New Paste');
	$short = pht('Create');
	}

	$form->appendChild($submit);

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

	$crumbs = $this->buildApplicationCrumbs($this->buildSideNavView());
	if (!$is_create) {
	$crumbs->addTextCrumb('P'.$paste->getID(), '/P'.$paste->getID());
	}
	$crumbs->addTextCrumb($short);

	return $this->buildApplicationPage(
	array(
	$crumbs,
	$form_box,
	),
	array(
	'title' => $title,
	'device' => true,
	));
	}

	}
	diff --git a/src/applications/paste/editor/PhabricatorPasteEditor.php b/src/applications/paste/editor/PhabricatorPasteEditor.php
	index 599cdd4d4b..1c9eded342 100644
	--- a/src/applications/paste/editor/PhabricatorPasteEditor.php
	+++ b/src/applications/paste/editor/PhabricatorPasteEditor.php
	@@ -1,168 +1,172 @@
	<?php

	final class PhabricatorPasteEditor
	extends PhabricatorApplicationTransactionEditor {

	private $pasteFile;

	public static function initializeFileForPaste(
	PhabricatorUser $actor,
	$name,
	$data) {

	return PhabricatorFile::newFromFileData(
	$data,
	array(
	'name' => $name,
	'mime-type' => 'text/plain; charset=utf-8',
	'authorPHID' => $actor->getPHID(),
	'viewPolicy' => PhabricatorPolicies::POLICY_NOONE,
	));
	}

	public function getTransactionTypes() {
	$types = parent::getTransactionTypes();

	- $types[] = PhabricatorPasteTransaction::TYPE_CREATE;
	+ $types[] = PhabricatorPasteTransaction::TYPE_CONTENT;
	$types[] = PhabricatorPasteTransaction::TYPE_TITLE;
	$types[] = PhabricatorPasteTransaction::TYPE_LANGUAGE;
	$types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
	$types[] = PhabricatorTransactions::TYPE_COMMENT;

	return $types;
	}

	protected function getCustomTransactionOldValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	- case PhabricatorPasteTransaction::TYPE_CREATE:
	- return null;
	+ case PhabricatorPasteTransaction::TYPE_CONTENT:
	+ return $object->getFilePHID();
	case PhabricatorPasteTransaction::TYPE_TITLE:
	return $object->getTitle();
	case PhabricatorPasteTransaction::TYPE_LANGUAGE:
	return $object->getLanguage();
	}
	}

	protected function getCustomTransactionNewValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	- case PhabricatorPasteTransaction::TYPE_CREATE:
	+ case PhabricatorPasteTransaction::TYPE_CONTENT:
	case PhabricatorPasteTransaction::TYPE_TITLE:
	case PhabricatorPasteTransaction::TYPE_LANGUAGE:
	return $xaction->getNewValue();
	}
	}

	protected function applyCustomInternalTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	- case PhabricatorPasteTransaction::TYPE_CREATE:
	+ case PhabricatorPasteTransaction::TYPE_CONTENT:
	$object->setFilePHID($xaction->getNewValue());
	return;
	case PhabricatorPasteTransaction::TYPE_TITLE:
	$object->setTitle($xaction->getNewValue());
	return;
	case PhabricatorPasteTransaction::TYPE_LANGUAGE:
	$object->setLanguage($xaction->getNewValue());
	return;
	+ case PhabricatorTransactions::TYPE_VIEW_POLICY:
	+ $object->setViewPolicy($xaction->getNewValue());
	+ return;
	}

	return parent::applyCustomInternalTransaction($object, $xaction);
	}

	protected function applyCustomExternalTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	- case PhabricatorPasteTransaction::TYPE_CREATE:
	+ case PhabricatorPasteTransaction::TYPE_CONTENT:
	case PhabricatorPasteTransaction::TYPE_TITLE:
	case PhabricatorPasteTransaction::TYPE_LANGUAGE:
	+ case PhabricatorTransactions::TYPE_VIEW_POLICY:
	return;
	}

	return parent::applyCustomExternalTransaction($object, $xaction);
	}

	protected function extractFilePHIDsFromCustomTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	- case PhabricatorPasteTransaction::TYPE_CREATE:
	+ case PhabricatorPasteTransaction::TYPE_CONTENT:
	return array($xaction->getNewValue());
	}

	return parent::extractFilePHIDsFromCustomTransaction($object, $xaction);
	}

	protected function shouldSendMail(
	PhabricatorLiskDAO $object,
	array $xactions) {
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	- case PhabricatorPasteTransaction::TYPE_CREATE:
	+ case PhabricatorPasteTransaction::TYPE_CONTENT:
	return false;
	default:
	break;
	}
	}
	return true;
	}

	protected function getMailSubjectPrefix() {
	return PhabricatorEnv::getEnvConfig('metamta.paste.subject-prefix');
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	return array(
	$object->getAuthorPHID(),
	$this->requireActor()->getPHID(),
	);
	}

	protected function buildReplyHandler(PhabricatorLiskDAO $object) {
	return id(new PasteReplyHandler())
	->setMailReceiver($object);
	}

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	$id = $object->getID();
	$name = $object->getTitle();

	return id(new PhabricatorMetaMTAMail())
	->setSubject("P{$id}: {$name}")
	->addHeader('Thread-Topic', "P{$id}");
	}

	protected function buildMailBody(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$body = parent::buildMailBody($object, $xactions);

	$body->addTextSection(
	pht('PASTE DETAIL'),
	PhabricatorEnv::getProductionURI('/P'.$object->getID()));

	return $body;
	}

	protected function shouldPublishFeedStory(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return true;
	}

	protected function supportsSearch() {
	return false;
	}

	}
	diff --git a/src/applications/paste/mail/PasteCreateMailReceiver.php b/src/applications/paste/mail/PasteCreateMailReceiver.php
	index 885c518990..5693a0e768 100644
	--- a/src/applications/paste/mail/PasteCreateMailReceiver.php
	+++ b/src/applications/paste/mail/PasteCreateMailReceiver.php
	@@ -1,93 +1,93 @@
	<?php

	/**
	* @group paste
	*/
	final class PasteCreateMailReceiver
	extends PhabricatorMailReceiver {

	public function isEnabled() {
	$app_class = 'PhabricatorApplicationPaste';
	return PhabricatorApplication::isClassInstalled($app_class);
	}

	public function canAcceptMail(PhabricatorMetaMTAReceivedMail $mail) {
	$config_key = 'metamta.paste.public-create-email';
	$create_address = PhabricatorEnv::getEnvConfig($config_key);
	if (!$create_address) {
	return false;
	}

	foreach ($mail->getToAddresses() as $to_address) {
	if ($this->matchAddresses($create_address, $to_address)) {
	return true;
	}
	}

	return false;
	}

	protected function processReceivedMail(
	PhabricatorMetaMTAReceivedMail $mail,
	PhabricatorUser $sender) {

	$title = $mail->getSubject();
	if (!$title) {
	$title = pht('Email Paste');
	}

	$file = PhabricatorPasteEditor::initializeFileForPaste(
	$sender,
	$title,
	$mail->getCleanTextBody());

	$xactions = array();

	$xactions[] = id(new PhabricatorPasteTransaction())
	- ->setTransactionType(PhabricatorPasteTransaction::TYPE_CREATE)
	+ ->setTransactionType(PhabricatorPasteTransaction::TYPE_CONTENT)
	->setNewValue($file->getPHID());

	$xactions[] = id(new PhabricatorPasteTransaction())
	->setTransactionType(PhabricatorPasteTransaction::TYPE_TITLE)
	->setNewValue($title);

	$xactions[] = id(new PhabricatorPasteTransaction())
	->setTransactionType(PhabricatorPasteTransaction::TYPE_LANGUAGE)
	->setNewValue(''); // auto-detect

	$paste = PhabricatorPaste::initializeNewPaste($sender);

	$content_source = PhabricatorContentSource::newForSource(
	PhabricatorContentSource::SOURCE_EMAIL,
	array(
	'id' => $mail->getID(),
	));

	$editor = id(new PhabricatorPasteEditor())
	->setActor($sender)
	->setContentSource($content_source)
	->setContinueOnNoEffect(true);
	$xactions = $editor->applyTransactions($paste, $xactions);

	$mail->setRelatedPHID($paste->getPHID());

	$subject_prefix =
	PhabricatorEnv::getEnvConfig('metamta.paste.subject-prefix');
	$subject = pht('You successfully created a paste.');
	$paste_uri = PhabricatorEnv::getProductionURI($paste->getURI());
	$body = new PhabricatorMetaMTAMailBody();
	$body->addRawSection($subject);
	$body->addTextSection(pht('PASTE LINK'), $paste_uri);

	id(new PhabricatorMetaMTAMail())
	->addTos(array($sender->getPHID()))
	->setSubject($subject)
	->setSubjectPrefix($subject_prefix)
	->setFrom($sender->getPHID())
	->setRelatedPHID($paste->getPHID())
	->setBody($body->render())
	->saveAndSend();

	}

	}
	diff --git a/src/applications/paste/query/PhabricatorPasteQuery.php b/src/applications/paste/query/PhabricatorPasteQuery.php
	index c4db19e1ff..a1b88d1102 100644
	--- a/src/applications/paste/query/PhabricatorPasteQuery.php
	+++ b/src/applications/paste/query/PhabricatorPasteQuery.php
	@@ -1,257 +1,263 @@
	<?php

	/**
	* @group paste
	*/
	final class PhabricatorPasteQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $ids;
	private $phids;
	private $authorPHIDs;
	private $parentPHIDs;

	private $needContent;
	private $needRawContent;
	private $languages;
	private $includeNoLanguage;
	private $dateCreatedAfter;
	private $dateCreatedBefore;

	public function withIDs(array $ids) {
	$this->ids = $ids;
	return $this;
	}

	public function withPHIDs(array $phids) {
	$this->phids = $phids;
	return $this;
	}

	public function withAuthorPHIDs(array $phids) {
	$this->authorPHIDs = $phids;
	return $this;
	}

	public function withParentPHIDs(array $phids) {
	$this->parentPHIDs = $phids;
	return $this;
	}

	public function needContent($need_content) {
	$this->needContent = $need_content;
	return $this;
	}

	public function needRawContent($need_raw_content) {
	$this->needRawContent = $need_raw_content;
	return $this;
	}

	public function withLanguages(array $languages) {
	$this->includeNoLanguage = false;
	foreach ($languages as $key => $language) {
	if ($language === null) {
	$languages[$key] = '';
	continue;
	}
	}
	$this->languages = $languages;
	return $this;
	}

	public function withDateCreatedBefore($date_created_before) {
	$this->dateCreatedBefore = $date_created_before;
	return $this;
	}

	public function withDateCreatedAfter($date_created_after) {
	$this->dateCreatedAfter = $date_created_after;
	return $this;
	}

	protected function loadPage() {
	$table = new PhabricatorPaste();
	$conn_r = $table->establishConnection('r');

	$data = queryfx_all(
	$conn_r,
	'SELECT paste.* FROM %T paste %Q %Q %Q',
	$table->getTableName(),
	$this->buildWhereClause($conn_r),
	$this->buildOrderClause($conn_r),
	$this->buildLimitClause($conn_r));

	$pastes = $table->loadAllFromArray($data);

	return $pastes;
	}

	protected function didFilterPage(array $pastes) {
	if ($this->needRawContent) {
	$pastes = $this->loadRawContent($pastes);
	}

	if ($this->needContent) {
	$pastes = $this->loadContent($pastes);
	}

	return $pastes;
	}

	protected function buildWhereClause($conn_r) {
	$where = array();

	$where[] = $this->buildPagingClause($conn_r);

	if ($this->ids) {
	$where[] = qsprintf(
	$conn_r,
	'id IN (%Ld)',
	$this->ids);
	}

	if ($this->phids) {
	$where[] = qsprintf(
	$conn_r,
	'phid IN (%Ls)',
	$this->phids);
	}

	if ($this->authorPHIDs) {
	$where[] = qsprintf(
	$conn_r,
	'authorPHID IN (%Ls)',
	$this->authorPHIDs);
	}

	if ($this->parentPHIDs) {
	$where[] = qsprintf(
	$conn_r,
	'parentPHID IN (%Ls)',
	$this->parentPHIDs);
	}

	if ($this->languages) {
	$where[] = qsprintf(
	$conn_r,
	'language IN (%Ls)',
	$this->languages);
	}

	if ($this->dateCreatedAfter) {
	$where[] = qsprintf(
	$conn_r,
	'dateCreated >= %d',
	$this->dateCreatedAfter);
	}

	if ($this->dateCreatedBefore) {
	$where[] = qsprintf(
	$conn_r,
	'dateCreated <= %d',
	$this->dateCreatedBefore);
	}

	return $this->formatWhereClause($where);
	}

	private function getContentCacheKey(PhabricatorPaste $paste) {
	- return 'P'.$paste->getID().':content/'.$paste->getLanguage();
	+ return implode(
	+ ':',
	+ array(
	+ 'P'.$paste->getID(),
	+ $paste->getFilePHID(),
	+ $paste->getLanguage(),
	+ ));
	}

	private function loadRawContent(array $pastes) {
	$file_phids = mpull($pastes, 'getFilePHID');
	$files = id(new PhabricatorFileQuery())
	->setParentQuery($this)
	->setViewer($this->getViewer())
	->withPHIDs($file_phids)
	->execute();
	$files = mpull($files, null, 'getPHID');

	foreach ($pastes as $key => $paste) {
	$file = idx($files, $paste->getFilePHID());
	if (!$file) {
	unset($pastes[$key]);
	continue;
	}
	try {
	$paste->attachRawContent($file->loadFileData());
	} catch (Exception $ex) {
	// We can hit various sorts of file storage issues here. Just drop the
	// paste if the file is dead.
	unset($pastes[$key]);
	continue;
	}
	}

	return $pastes;
	}

	private function loadContent(array $pastes) {
	$cache = new PhabricatorKeyValueDatabaseCache();

	$cache = new PhutilKeyValueCacheProfiler($cache);
	$cache->setProfiler(PhutilServiceProfiler::getInstance());

	$keys = array();
	foreach ($pastes as $paste) {
	$keys[] = $this->getContentCacheKey($paste);
	}

	$caches = $cache->getKeys($keys);
	$results = array();

	$need_raw = array();
	foreach ($pastes as $key => $paste) {
	$key = $this->getContentCacheKey($paste);
	if (isset($caches[$key])) {
	$paste->attachContent(phutil_safe_html($caches[$key]));
	$results[$paste->getID()] = $paste;
	} else {
	$need_raw[$key] = $paste;
	}
	}

	if (!$need_raw) {
	return $results;
	}

	$write_data = array();

	$need_raw = $this->loadRawContent($need_raw);
	foreach ($need_raw as $key => $paste) {
	$content = $this->buildContent($paste);
	$paste->attachContent($content);

	$write_data[$this->getContentCacheKey($paste)] = (string)$content;
	$results[$paste->getID()] = $paste;
	}

	$cache->setKeys($write_data);

	return $results;
	}


	private function buildContent(PhabricatorPaste $paste) {
	$language = $paste->getLanguage();
	$source = $paste->getRawContent();

	if (empty($language)) {
	return PhabricatorSyntaxHighlighter::highlightWithFilename(
	$paste->getTitle(),
	$source);
	} else {
	return PhabricatorSyntaxHighlighter::highlightWithLanguage(
	$language,
	$source);
	}
	}


	public function getQueryApplicationClass() {
	return 'PhabricatorApplicationPaste';
	}

	}
	diff --git a/src/applications/paste/storage/PhabricatorPasteTransaction.php b/src/applications/paste/storage/PhabricatorPasteTransaction.php
	index a62f6be5f2..acb06b22ac 100644
	--- a/src/applications/paste/storage/PhabricatorPasteTransaction.php
	+++ b/src/applications/paste/storage/PhabricatorPasteTransaction.php
	@@ -1,131 +1,185 @@
	<?php

	final class PhabricatorPasteTransaction
	extends PhabricatorApplicationTransaction {

	- const TYPE_CREATE = 'paste.create';
	+ const TYPE_CONTENT = 'paste.create';
	const TYPE_TITLE = 'paste.title';
	const TYPE_LANGUAGE = 'paste.language';

	public function getApplicationName() {
	return 'pastebin';
	}

	public function getApplicationTransactionType() {
	return PhabricatorPastePHIDTypePaste::TYPECONST;
	}

	public function getApplicationTransactionCommentObject() {
	return new PhabricatorPasteTransactionComment();
	}

	public function getRequiredHandlePHIDs() {
	$phids = parent::getRequiredHandlePHIDs();

	switch ($this->getTransactionType()) {
	- case self::TYPE_CREATE:
	+ case self::TYPE_CONTENT:
	$phids[] = $this->getObjectPHID();
	break;
	}

	return $phids;
	}

	public function shouldHide() {
	$old = $this->getOldValue();
	switch ($this->getTransactionType()) {
	case self::TYPE_TITLE:
	case self::TYPE_LANGUAGE:
	- return $old === null;
	+ return ($old === null);
	}
	return parent::shouldHide();
	}

	public function getIcon() {
	switch ($this->getTransactionType()) {
	- case self::TYPE_CREATE:
	+ case self::TYPE_CONTENT:
	return 'fa-plus';
	break;
	case self::TYPE_TITLE:
	case self::TYPE_LANGUAGE:
	return 'fa-pencil';
	break;
	}
	return parent::getIcon();
	}

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

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

	$type = $this->getTransactionType();
	switch ($type) {
	- case PhabricatorPasteTransaction::TYPE_CREATE:
	- return pht(
	- '%s created "%s".',
	- $this->renderHandleLink($author_phid),
	- $this->renderHandleLink($object_phid));
	+ case PhabricatorPasteTransaction::TYPE_CONTENT:
	+ if ($old === null) {
	+ return pht(
	+ '%s created this paste.',
	+ $this->renderHandleLink($author_phid));
	+ } else {
	+ return pht(
	+ '%s edited the content of this paste.',
	+ $this->renderHandleLink($author_phid));
	+ }
	break;
	case PhabricatorPasteTransaction::TYPE_TITLE:
	return pht(
	'%s updated the paste\'s title to "%s".',
	$this->renderHandleLink($author_phid),
	$new);
	break;
	case PhabricatorPasteTransaction::TYPE_LANGUAGE:
	return pht(
	"%s updated the paste's language.",
	$this->renderHandleLink($author_phid));
	break;
	}

	return parent::getTitle();
	}

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

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

	$type = $this->getTransactionType();
	switch ($type) {
	- case PhabricatorPasteTransaction::TYPE_CREATE:
	- return pht(
	- '%s created %s.',
	- $this->renderHandleLink($author_phid),
	- $this->renderHandleLink($object_phid));
	+ case PhabricatorPasteTransaction::TYPE_CONTENT:
	+ if ($old === null) {
	+ return pht(
	+ '%s created %s.',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid));
	+ } else {
	+ return pht(
	+ '%s edited %s.',
	+ $this->renderHandleLink($author_phid),
	+ $this->renderHandleLink($object_phid));
	+ }
	break;
	case PhabricatorPasteTransaction::TYPE_TITLE:
	return pht(
	'%s updated the title for %s.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($object_phid));
	break;
	case PhabricatorPasteTransaction::TYPE_LANGUAGE:
	return pht(
	'%s update the language for %s.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($object_phid));
	break;
	}

	return parent::getTitleForFeed($story);
	}

	public function getColor() {
	$old = $this->getOldValue();
	$new = $this->getNewValue();

	switch ($this->getTransactionType()) {
	- case PhabricatorPasteTransaction::TYPE_CREATE:
	+ case self::TYPE_CONTENT:
	return PhabricatorTransactions::COLOR_GREEN;
	}

	return parent::getColor();
	}
	+
	+
	+ public function hasChangeDetails() {
	+ switch ($this->getTransactionType()) {
	+ case self::TYPE_CONTENT:
	+ return ($this->getOldValue() !== null);
	+ }
	+
	+ return parent::hasChangeDetails();
	+ }
	+
	+ public function renderChangeDetails(PhabricatorUser $viewer) {
	+ switch ($this->getTransactionType()) {
	+ case self::TYPE_CONTENT:
	+ $old = $this->getOldValue();
	+ $new = $this->getNewValue();
	+
	+ $files = id(new PhabricatorFileQuery())
	+ ->setViewer($viewer)
	+ ->withPHIDs(array_filter(array($old, $new)))
	+ ->execute();
	+ $files = mpull($files, null, 'getPHID');
	+
	+ $old_text = '';
	+ if (idx($files, $old)) {
	+ $old_text = $files[$old]->loadFileData();
	+ }
	+
	+ $new_text = '';
	+ if (idx($files, $new)) {
	+ $new_text = $files[$new]->loadFileData();
	+ }
	+
	+ return $this->renderTextCorpusChangeDetails(
	+ $viewer,
	+ $old_text,
	+ $new_text);
	+ }
	+
	+ return parent::renderChangeDetails($viewer);
	+ }
	+
	}
	diff --git a/src/applications/transactions/storage/PhabricatorApplicationTransaction.php b/src/applications/transactions/storage/PhabricatorApplicationTransaction.php
	index d074f3f799..aa0f24ab7b 100644
	--- a/src/applications/transactions/storage/PhabricatorApplicationTransaction.php
	+++ b/src/applications/transactions/storage/PhabricatorApplicationTransaction.php
	@@ -1,975 +1,978 @@
	<?php

	abstract class PhabricatorApplicationTransaction
	extends PhabricatorLiskDAO
	implements
	PhabricatorPolicyInterface,
	PhabricatorDestructableInterface {

	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();
	private $viewer = self::ATTACHABLE;
	private $object = self::ATTACHABLE;
	private $oldValueHasBeenSet = false;

	private $ignoreOnNoEffect;


	/**
	* Flag this transaction as a pure side-effect which should be ignored when
	* applying transactions if it has no effect, even if transaction application
	* would normally fail. This both provides users with better error messages
	* and allows transactions to perform optional side effects.
	*/
	public function setIgnoreOnNoEffect($ignore) {
	$this->ignoreOnNoEffect = $ignore;
	return $this;
	}

	public function getIgnoreOnNoEffect() {
	return $this->ignoreOnNoEffect;
	}

	public function shouldGenerateOldValue() {
	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_BUILDABLE:
	case PhabricatorTransactions::TYPE_TOKEN:
	case PhabricatorTransactions::TYPE_CUSTOMFIELD:
	return false;
	}
	return true;
	}

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

	public function attachObject($object) {
	$this->object = $object;
	return $this;
	}

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

	public function getRemarkupBlocks() {
	$blocks = array();

	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_CUSTOMFIELD:
	$field = $this->getTransactionCustomField();
	if ($field) {
	$custom_blocks = $field->getApplicationTransactionRemarkupBlocks(
	$this);
	foreach ($custom_blocks as $custom_block) {
	$blocks[] = $custom_block;
	}
	}
	break;
	}

	if ($this->getComment()) {
	$blocks[] = $this->getComment()->getContent();
	}

	return $blocks;
	}

	public function setOldValue($value) {
	$this->oldValueHasBeenSet = true;
	$this->writeField('oldValue', $value);
	return $this;
	}

	public function hasOldValue() {
	return $this->oldValueHasBeenSet;
	}


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

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

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

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

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

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

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

	$phids[] = array($this->getAuthorPHID());
	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_CUSTOMFIELD:
	$field = $this->getTransactionCustomField();
	if ($field) {
	$phids[] = $field->getApplicationTransactionRequiredHandlePHIDs(
	$this);
	}
	break;
	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:
	case PhabricatorTransactions::TYPE_JOIN_POLICY:
	if (!PhabricatorPolicyQuery::isGlobalPolicy($old)) {
	$phids[] = array($old);
	}
	if (!PhabricatorPolicyQuery::isGlobalPolicy($new)) {
	$phids[] = array($new);
	}
	break;
	case PhabricatorTransactions::TYPE_TOKEN:
	break;
	case PhabricatorTransactions::TYPE_BUILDABLE:
	$phid = $this->getMetadataValue('harbormaster:buildablePHID');
	if ($phid) {
	$phids[] = array($phid);
	}
	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(
	pht(
	'Transaction ("%s") requires a handle ("%s") that it did not '.
	'load.',
	$this->getPHID(),
	$phid));
	}
	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 $this->getHandle($phid)->getLinkName();
	}
	}

	public function renderHandleList(array $phids) {
	$links = array();
	foreach ($phids as $phid) {
	$links[] = $this->renderHandleLink($phid);
	}
	if ($this->renderingTarget == self::TARGET_HTML) {
	return phutil_implode_html(', ', $links);
	} else {
	return implode(', ', $links);
	}
	}

	private function renderSubscriberList(array $phids, $change_type) {
	if ($this->getRenderingTarget() == self::TARGET_TEXT) {
	return $this->renderHandleList($phids);
	} else {
	$handles = array_select_keys($this->getHandles(), $phids);
	return id(new SubscriptionListStringBuilder())
	->setHandles($handles)
	->setObjectPHID($this->getPHID())
	->buildTransactionString($change_type);
	}
	}

	protected function renderPolicyName($phid, $state = 'old') {
	$policy = PhabricatorPolicy::newFromPolicyAndHandle(
	$phid,
	$this->getHandleIfExists($phid));
	if ($this->renderingTarget == self::TARGET_HTML) {
	switch ($policy->getType()) {
	case PhabricatorPolicyType::TYPE_CUSTOM:
	$policy->setHref('/transactions/'.$state.'/'.$this->getPHID().'/');
	$policy->setWorkflow(true);
	break;
	default:
	break;
	}
	$output = $policy->renderDescription();
	} else {
	$output = hsprintf('%s', $policy->getFullName());
	}
	return $output;
	}

	public function getIcon() {
	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	return 'fa-comment';
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	return 'fa-envelope';
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	case PhabricatorTransactions::TYPE_JOIN_POLICY:
	return 'fa-lock';
	case PhabricatorTransactions::TYPE_EDGE:
	return 'fa-link';
	case PhabricatorTransactions::TYPE_BUILDABLE:
	return 'fa-wrench';
	case PhabricatorTransactions::TYPE_TOKEN:
	if ($this->getNewValue()) {
	return 'fa-thumbs-o-up';
	} else {
	return 'fa-thumbs-o-down';
	}
	}

	return 'fa-pencil';
	}

	public function getToken() {
	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_TOKEN:
	$old = $this->getOldValue();
	$new = $this->getNewValue();
	if ($new) {
	$icon = substr($new, 10);
	} else {
	$icon = substr($old, 10);
	}
	return array($icon, !$this->getNewValue());
	}

	return array(null, null);
	}

	public function getColor() {
	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_BUILDABLE:
	switch ($this->getNewValue()) {
	case HarbormasterBuildable::STATUS_PASSED:
	return 'green';
	case HarbormasterBuildable::STATUS_FAILED:
	return 'red';
	}
	break;
	}
	return null;
	}

	protected function getTransactionCustomField() {
	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_CUSTOMFIELD:
	$key = $this->getMetadataValue('customfield:key');
	if (!$key) {
	return null;
	}

	$field = PhabricatorCustomField::getObjectField(
	$this->getObject(),
	PhabricatorCustomField::ROLE_APPLICATIONTRANSACTIONS,
	$key);
	if (!$field) {
	return null;
	}

	$field->setViewer($this->getViewer());
	return $field;
	}

	return null;
	}

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

	return false;
	}

	public function shouldHideForMail(array $xactions) {
	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_TOKEN:
	return true;
	case PhabricatorTransactions::TYPE_BUILDABLE:
	switch ($this->getNewValue()) {
	case HarbormasterBuildable::STATUS_PASSED:
	// For now, just never send mail when builds pass. We might let
	// you customize this later, but in most cases this is probably
	// completely uninteresting.
	return true;
	}
	}

	return $this->shouldHide();
	}

	public function shouldHideForFeed() {
	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_TOKEN:
	return true;
	case PhabricatorTransactions::TYPE_BUILDABLE:
	switch ($this->getNewValue()) {
	case HarbormasterBuildable::STATUS_PASSED:
	// For now, don't notify on build passes either. These are pretty
	// high volume and annoying, with very little present value. We
	// might want to turn them back on in the specific case of
	// build successes on the current document?
	return true;
	}
	}

	return $this->shouldHide();
	}

	public function getTitleForMail() {
	return id(clone $this)->setRenderingTarget('text')->getTitle();
	}

	public function getBodyForMail() {
	$comment = $this->getComment();
	if ($comment && strlen($comment->getContent())) {
	return $comment->getContent();
	}
	return null;
	}

	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_JOIN_POLICY:
	return pht(
	'This %s already has that join 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(),
	$this->renderPolicyName($old, 'old'),
	$this->renderPolicyName($new, 'new'));
	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(),
	$this->renderPolicyName($old, 'old'),
	$this->renderPolicyName($new, 'new'));
	case PhabricatorTransactions::TYPE_JOIN_POLICY:
	return pht(
	'%s changed the join policy of this %s from "%s" to "%s".',
	$this->renderHandleLink($author_phid),
	$this->getApplicationObjectTypeName(),
	$this->renderPolicyName($old, 'old'),
	$this->renderPolicyName($new, 'new'));
	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->renderSubscriberList($add, 'add'),
	count($rem),
	$this->renderSubscriberList($rem, 'rem'));
	} else if ($add) {
	return pht(
	'%s added %d subscriber(s): %s.',
	$this->renderHandleLink($author_phid),
	count($add),
	$this->renderSubscriberList($add, 'add'));
	} else if ($rem) {
	return pht(
	'%s removed %d subscriber(s): %s.',
	$this->renderHandleLink($author_phid),
	count($rem),
	$this->renderSubscriberList($rem, 'rem'));
	} else {
	// This is used when rendering previews, before the user actually
	// selects any CCs.
	return pht(
	'%s updated subscribers...',
	$this->renderHandleLink($author_phid));
	}
	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 if ($rem) {
	$string = PhabricatorEdgeConfig::getRemoveStringForEdgeType($type);
	return pht(
	$string,
	$this->renderHandleLink($author_phid),
	count($rem),
	$this->renderHandleList($rem));
	} else {
	return pht(
	'%s edited edge metadata.',
	$this->renderHandleLink($author_phid));
	}

	case PhabricatorTransactions::TYPE_CUSTOMFIELD:
	$field = $this->getTransactionCustomField();
	if ($field) {
	return $field->getApplicationTransactionTitle($this);
	} else {
	return pht(
	'%s edited a custom field.',
	$this->renderHandleLink($author_phid));
	}

	case PhabricatorTransactions::TYPE_TOKEN:
	if ($old && $new) {
	return pht(
	'%s updated a token.',
	$this->renderHandleLink($author_phid));
	} else if ($old) {
	return pht(
	'%s rescinded a token.',
	$this->renderHandleLink($author_phid));
	} else {
	return pht(
	'%s awarded a token.',
	$this->renderHandleLink($author_phid));
	}

	case PhabricatorTransactions::TYPE_BUILDABLE:
	switch ($this->getNewValue()) {
	case HarbormasterBuildable::STATUS_PASSED:
	return pht(
	'%s completed building %s.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink(
	$this->getMetadataValue('harbormaster:buildablePHID')));
	case HarbormasterBuildable::STATUS_FAILED:
	return pht(
	'%s failed to build %s!',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink(
	$this->getMetadataValue('harbormaster:buildablePHID')));
	default:
	return null;
	}

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

	public function getTitleForFeed(PhabricatorFeedStory $story) {
	$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_JOIN_POLICY:
	return pht(
	'%s changed the join 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));
	case PhabricatorTransactions::TYPE_CUSTOMFIELD:
	$field = $this->getTransactionCustomField();
	if ($field) {
	return $field->getApplicationTransactionTitleForFeed($this, $story);
	} else {
	return pht(
	'%s edited a custom field on %s.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($object_phid));
	}
	case PhabricatorTransactions::TYPE_BUILDABLE:
	switch ($this->getNewValue()) {
	case HarbormasterBuildable::STATUS_PASSED:
	return pht(
	'%s completed building %s for %s.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink(
	$this->getMetadataValue('harbormaster:buildablePHID')),
	$this->renderHandleLink($object_phid));
	case HarbormasterBuildable::STATUS_FAILED:
	return pht(
	'%s failed to build %s for %s.',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink(
	$this->getMetadataValue('harbormaster:buildablePHID')),
	$this->renderHandleLink($object_phid));
	default:
	return null;
	}

	}

	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 isCommentTransaction() {
	if ($this->hasComment()) {
	return true;
	}

	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	return true;
	}

	return false;
	}

	public function getActionName() {
	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	return pht('Commented On');
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	case PhabricatorTransactions::TYPE_JOIN_POLICY:
	return pht('Changed Policy');
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	return pht('Changed Subscribers');
	case PhabricatorTransactions::TYPE_BUILDABLE:
	switch ($this->getNewValue()) {
	case HarbormasterBuildable::STATUS_PASSED:
	return pht('Build Passed');
	case HarbormasterBuildable::STATUS_FAILED:
	return pht('Build Failed');
	default:
	return pht('Build Status');
	}
	default:
	return pht('Updated');
	}
	}

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

	public function hasChangeDetails() {
	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_CUSTOMFIELD:
	$field = $this->getTransactionCustomField();
	if ($field) {
	return $field->getApplicationTransactionHasChangeDetails($this);
	}
	break;
	}
	return false;
	}

	public function renderChangeDetails(PhabricatorUser $viewer) {
	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_CUSTOMFIELD:
	$field = $this->getTransactionCustomField();
	if ($field) {
	return $field->getApplicationTransactionChangeDetails($this, $viewer);
	}
	break;
	}

	- return $this->renderTextCorpusChangeDetails();
	+ return $this->renderTextCorpusChangeDetails(
	+ $viewer,
	+ $this->getOldValue(),
	+ $this->getNewValue());
	}

	public function renderTextCorpusChangeDetails(
	PhabricatorUser $viewer,
	$old,
	$new) {

	require_celerity_resource('differential-changeset-view-css');

	$view = id(new PhabricatorApplicationTransactionTextDiffDetailView())
	->setUser($viewer)
	->setOldText($old)
	->setNewText($new);

	return $view->render();
	}

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

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

	/**
	* Should this transaction be visually grouped with an existing transaction
	* group?
	*
	* @param list<PhabricatorApplicationTransaction> List of transactions.
	* @return bool True to display in a group with the other transactions.
	*/
	public function shouldDisplayGroupWith(array $group) {
	$this_source = null;
	if ($this->getContentSource()) {
	$this_source = $this->getContentSource()->getSource();
	}

	foreach ($group as $xaction) {
	// Don't group transactions by different authors.
	if ($xaction->getAuthorPHID() != $this->getAuthorPHID()) {
	return false;
	}

	// Don't group transactions for different objects.
	if ($xaction->getObjectPHID() != $this->getObjectPHID()) {
	return false;
	}

	// Don't group anything into a group which already has a comment.
	if ($xaction->isCommentTransaction()) {
	return false;
	}

	// Don't group transactions from different content sources.
	$other_source = null;
	if ($xaction->getContentSource()) {
	$other_source = $xaction->getContentSource()->getSource();
	}

	if ($other_source != $this_source) {
	return false;
	}

	// Don't group transactions which happened more than 2 minutes apart.
	$apart = abs($xaction->getDateCreated() - $this->getDateCreated());
	if ($apart > (60 * 2)) {
	return false;
	}
	}

	return true;
	}

	public function renderExtraInformationLink() {
	$herald_xscript_id = $this->getMetadataValue('herald:transcriptID');

	if ($herald_xscript_id) {
	return phutil_tag(
	'a',
	array(
	'href' => '/herald/transcript/'.$herald_xscript_id.'/',
	),
	pht('View Herald Transcript'));
	}

	return null;
	}


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

	public function describeAutomaticCapability($capability) {
	// TODO: (T603) Exact policies are unclear here.
	return null;
	}


	/* -( PhabricatorDestructableInterface )----------------------------------- */


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

	$this->openTransaction();
	$comment_template = null;
	try {
	$comment_template = $this->getApplicationTransactionCommentObject();
	} catch (Exception $ex) {
	// Continue; no comments for these transactions.
	}

	if ($comment_template) {
	$comments = $comment_template->loadAllWhere(
	'transactionPHID = %s',
	$this->getPHID());
	foreach ($comments as $comment) {
	$engine->destroyObject($comment);
	}
	}

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


	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Jul 28, 6:39 AM (1 w, 20 h ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 186466
Default Alt Text: (63 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions