No OneTemporary
Actions

Size

122 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/maniphest/editor/ManiphestEditEngine.php b/src/applications/maniphest/editor/ManiphestEditEngine.php
	index 71ae414de2..8df261dc4a 100644
	--- a/src/applications/maniphest/editor/ManiphestEditEngine.php
	+++ b/src/applications/maniphest/editor/ManiphestEditEngine.php
	@@ -1,526 +1,527 @@
	<?php

	final class ManiphestEditEngine
	extends PhabricatorEditEngine {

	const ENGINECONST = 'maniphest.task';

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

	public function getSummaryHeader() {
	return pht('Configure Maniphest Task Forms');
	}

	public function getSummaryText() {
	return pht('Configure how users create and edit tasks.');
	}

	public function getEngineApplicationClass() {
	return 'PhabricatorManiphestApplication';
	}

	public function isDefaultQuickCreateEngine() {
	return true;
	}

	public function getQuickCreateOrderVector() {
	return id(new PhutilSortVector())->addInt(100);
	}

	protected function newEditableObject() {
	return ManiphestTask::initializeNewTask($this->getViewer());
	}

	protected function newObjectQuery() {
	return id(new ManiphestTaskQuery());
	}

	protected function getObjectCreateTitleText($object) {
	return pht('Create New Task');
	}

	protected function getObjectEditTitleText($object) {
	return pht('Edit Task: %s', $object->getTitle());
	}

	protected function getObjectEditShortText($object) {
	return $object->getMonogram();
	}

	protected function getObjectCreateShortText() {
	return pht('Create Task');
	}

	protected function getObjectName() {
	return pht('Task');
	}

	protected function getEditorURI() {
	return $this->getApplication()->getApplicationURI('task/edit/');
	}

	protected function getCommentViewHeaderText($object) {
	return pht('Weigh In');
	}

	protected function getCommentViewButtonText($object) {
	return pht('Set Sail for Adventure');
	}

	protected function getObjectViewURI($object) {
	return '/'.$object->getMonogram();
	}

	protected function buildCustomEditFields($object) {
	$status_map = $this->getTaskStatusMap($object);
	$priority_map = $this->getTaskPriorityMap($object);

	$alias_map = ManiphestTaskPriority::getTaskPriorityAliasMap();

	if ($object->isClosed()) {
	$default_status = ManiphestTaskStatus::getDefaultStatus();
	} else {
	$default_status = ManiphestTaskStatus::getDefaultClosedStatus();
	}

	if ($object->getOwnerPHID()) {
	$owner_value = array($object->getOwnerPHID());
	} else {
	$owner_value = array($this->getViewer()->getPHID());
	}

	$column_documentation = pht(<<<EODOCS
	You can use this transaction type to create a task into a particular workboard
	column, or move an existing task between columns.

	The transaction value can be specified in several forms. Some are simpler but
	less powerful, while others are more complex and more powerful.

	The simplest valid value is a single column PHID:

	```lang=json
	"PHID-PCOL-1111"
	```

	This will move the task into that column, or create the task into that column
	if you are creating a new task. If the task is currently on the board, it will
	be moved out of any exclusive columns. If the task is not currently on the
	board, it will be added to the board.

	You can also perform multiple moves at the same time by passing a list of
	PHIDs:

	```lang=json
	["PHID-PCOL-2222", "PHID-PCOL-3333"]
	```

	This is equivalent to performing each move individually.

	The most complex and most powerful form uses a dictionary to provide additional
	information about the move, including an optional specific position within the
	column.

	The target column should be identified as `columnPHID`, and you may select a
	position by passing either `beforePHID` or `afterPHID`, specifying the PHID of
	a task currently in the column that you want to move this task before or after:

	```lang=json
	[
	{
	"columnPHID": "PHID-PCOL-4444",
	"beforePHID": "PHID-TASK-5555"
	}
	]
	```

	Note that this affects only the "natural" position of the task. The task
	position when the board is sorted by some other attribute (like priority)
	depends on that attribute value: change a task's priority to move it on
	priority-sorted boards.
	EODOCS
	);

	$column_map = $this->getColumnMap($object);

	$fields = array(
	id(new PhabricatorHandlesEditField())
	->setKey('parent')
	->setLabel(pht('Parent Task'))
	->setDescription(pht('Task to make this a subtask of.'))
	->setConduitDescription(pht('Create as a subtask of another task.'))
	->setConduitTypeDescription(pht('PHID of the parent task.'))
	->setAliases(array('parentPHID'))
	->setTransactionType(ManiphestTaskParentTransaction::TRANSACTIONTYPE)
	->setHandleParameterType(new ManiphestTaskListHTTPParameterType())
	->setSingleValue(null)
	->setIsReorderable(false)
	->setIsDefaultable(false)
	->setIsLockable(false),
	id(new PhabricatorColumnsEditField())
	->setKey('column')
	->setLabel(pht('Column'))
	->setDescription(pht('Create a task in a workboard column.'))
	->setConduitDescription(
	pht('Move a task to one or more workboard columns.'))
	->setConduitTypeDescription(
	pht('List of columns to move the task to.'))
	->setConduitDocumentation($column_documentation)
	->setAliases(array('columnPHID', 'columns', 'columnPHIDs'))
	->setTransactionType(PhabricatorTransactions::TYPE_COLUMNS)
	->setIsReorderable(false)
	->setIsDefaultable(false)
	->setIsLockable(false)
	->setCommentActionLabel(pht('Move on Workboard'))
	->setCommentActionOrder(2000)
	->setColumnMap($column_map),
	id(new PhabricatorTextEditField())
	->setKey('title')
	->setLabel(pht('Title'))
	->setBulkEditLabel(pht('Set title to'))
	->setDescription(pht('Name of the task.'))
	->setConduitDescription(pht('Rename the task.'))
	->setConduitTypeDescription(pht('New task name.'))
	->setTransactionType(ManiphestTaskTitleTransaction::TRANSACTIONTYPE)
	->setIsRequired(true)
	->setValue($object->getTitle()),
	id(new PhabricatorUsersEditField())
	->setKey('owner')
	->setAliases(array('ownerPHID', 'assign', 'assigned'))
	->setLabel(pht('Assigned To'))
	+ ->setBulkEditLabel(pht('Assign to'))
	->setDescription(pht('User who is responsible for the task.'))
	->setConduitDescription(pht('Reassign the task.'))
	->setConduitTypeDescription(
	pht('New task owner, or `null` to unassign.'))
	->setTransactionType(ManiphestTaskOwnerTransaction::TRANSACTIONTYPE)
	->setIsCopyable(true)
	->setSingleValue($object->getOwnerPHID())
	->setCommentActionLabel(pht('Assign / Claim'))
	->setCommentActionValue($owner_value),
	id(new PhabricatorSelectEditField())
	->setKey('status')
	->setLabel(pht('Status'))
	->setBulkEditLabel(pht('Set status to'))
	->setDescription(pht('Status of the task.'))
	->setConduitDescription(pht('Change the task status.'))
	->setConduitTypeDescription(pht('New task status constant.'))
	->setTransactionType(ManiphestTaskStatusTransaction::TRANSACTIONTYPE)
	->setIsCopyable(true)
	->setValue($object->getStatus())
	->setOptions($status_map)
	->setCommentActionLabel(pht('Change Status'))
	->setCommentActionValue($default_status),
	id(new PhabricatorSelectEditField())
	->setKey('priority')
	->setLabel(pht('Priority'))
	->setBulkEditLabel(pht('Set priority to'))
	->setDescription(pht('Priority of the task.'))
	->setConduitDescription(pht('Change the priority of the task.'))
	->setConduitTypeDescription(pht('New task priority constant.'))
	->setTransactionType(ManiphestTaskPriorityTransaction::TRANSACTIONTYPE)
	->setIsCopyable(true)
	->setValue($object->getPriorityKeyword())
	->setOptions($priority_map)
	->setOptionAliases($alias_map)
	->setCommentActionLabel(pht('Change Priority')),
	);

	if (ManiphestTaskPoints::getIsEnabled()) {
	$points_label = ManiphestTaskPoints::getPointsLabel();
	$action_label = ManiphestTaskPoints::getPointsActionLabel();

	$fields[] = id(new PhabricatorPointsEditField())
	->setKey('points')
	->setLabel($points_label)
	->setDescription(pht('Point value of the task.'))
	->setConduitDescription(pht('Change the task point value.'))
	->setConduitTypeDescription(pht('New task point value.'))
	->setTransactionType(ManiphestTaskPointsTransaction::TRANSACTIONTYPE)
	->setIsCopyable(true)
	->setValue($object->getPoints())
	->setCommentActionLabel($action_label);
	}

	$fields[] = id(new PhabricatorRemarkupEditField())
	->setKey('description')
	->setLabel(pht('Description'))
	->setBulkEditLabel(pht('Set description to'))
	->setDescription(pht('Task description.'))
	->setConduitDescription(pht('Update the task description.'))
	->setConduitTypeDescription(pht('New task description.'))
	->setTransactionType(ManiphestTaskDescriptionTransaction::TRANSACTIONTYPE)
	->setValue($object->getDescription())
	->setPreviewPanel(
	id(new PHUIRemarkupPreviewPanel())
	->setHeader(pht('Description Preview')));

	$parent_type = ManiphestTaskDependedOnByTaskEdgeType::EDGECONST;
	$subtask_type = ManiphestTaskDependsOnTaskEdgeType::EDGECONST;

	$src_phid = $object->getPHID();
	if ($src_phid) {
	$edge_query = id(new PhabricatorEdgeQuery())
	->withSourcePHIDs(array($src_phid))
	->withEdgeTypes(
	array(
	$parent_type,
	$subtask_type,
	));
	$edge_query->execute();

	$parent_phids = $edge_query->getDestinationPHIDs(
	array($src_phid),
	array($parent_type));

	$subtask_phids = $edge_query->getDestinationPHIDs(
	array($src_phid),
	array($subtask_type));
	} else {
	$parent_phids = array();
	$subtask_phids = array();
	}

	$fields[] = id(new PhabricatorHandlesEditField())
	->setKey('parents')
	->setLabel(pht('Parents'))
	->setDescription(pht('Parent tasks.'))
	->setConduitDescription(pht('Change the parents of this task.'))
	->setConduitTypeDescription(pht('List of parent task PHIDs.'))
	->setUseEdgeTransactions(true)
	->setIsConduitOnly(true)
	->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
	->setMetadataValue('edge:type', $parent_type)
	->setValue($parent_phids);

	$fields[] = id(new PhabricatorHandlesEditField())
	->setKey('subtasks')
	->setLabel(pht('Subtasks'))
	->setDescription(pht('Subtasks.'))
	->setConduitDescription(pht('Change the subtasks of this task.'))
	->setConduitTypeDescription(pht('List of subtask PHIDs.'))
	->setUseEdgeTransactions(true)
	->setIsConduitOnly(true)
	->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
	->setMetadataValue('edge:type', $subtask_type)
	->setValue($parent_phids);

	return $fields;
	}

	private function getTaskStatusMap(ManiphestTask $task) {
	$status_map = ManiphestTaskStatus::getTaskStatusMap();

	$current_status = $task->getStatus();

	// If the current status is something we don't recognize (maybe an older
	// status which was deleted), put a dummy entry in the status map so that
	// saving the form doesn't destroy any data by accident.
	if (idx($status_map, $current_status) === null) {
	$status_map[$current_status] = pht('<Unknown: %s>', $current_status);
	}

	$dup_status = ManiphestTaskStatus::getDuplicateStatus();
	foreach ($status_map as $status => $status_name) {
	// Always keep the task's current status.
	if ($status == $current_status) {
	continue;
	}

	// Don't allow tasks to be changed directly into "Closed, Duplicate"
	// status. Instead, you have to merge them. See T4819.
	if ($status == $dup_status) {
	unset($status_map[$status]);
	continue;
	}

	// Don't let new or existing tasks be moved into a disabled status.
	if (ManiphestTaskStatus::isDisabledStatus($status)) {
	unset($status_map[$status]);
	continue;
	}
	}

	return $status_map;
	}

	private function getTaskPriorityMap(ManiphestTask $task) {
	$priority_map = ManiphestTaskPriority::getTaskPriorityMap();
	$priority_keywords = ManiphestTaskPriority::getTaskPriorityKeywordsMap();
	$current_priority = $task->getPriority();
	$results = array();

	foreach ($priority_map as $priority => $priority_name) {
	$disabled = ManiphestTaskPriority::isDisabledPriority($priority);
	if ($disabled && !($priority == $current_priority)) {
	continue;
	}

	$keyword = head(idx($priority_keywords, $priority));
	$results[$keyword] = $priority_name;
	}

	// If the current value isn't a legitimate one, put it in the dropdown
	// anyway so saving the form doesn't cause any side effects.
	if (idx($priority_map, $current_priority) === null) {
	$results[ManiphestTaskPriority::UNKNOWN_PRIORITY_KEYWORD] = pht(
	'<Unknown: %s>',
	$current_priority);
	}

	return $results;
	}

	protected function newEditResponse(
	AphrontRequest $request,
	$object,
	array $xactions) {

	if ($request->isAjax()) {
	// Reload the task to make sure we pick up the final task state.
	$viewer = $this->getViewer();
	$task = id(new ManiphestTaskQuery())
	->setViewer($viewer)
	->withIDs(array($object->getID()))
	->needSubscriberPHIDs(true)
	->needProjectPHIDs(true)
	->executeOne();

	switch ($request->getStr('responseType')) {
	case 'card':
	return $this->buildCardResponse($task);
	default:
	return $this->buildListResponse($task);
	}

	}

	return parent::newEditResponse($request, $object, $xactions);
	}

	private function buildListResponse(ManiphestTask $task) {
	$controller = $this->getController();

	$payload = array(
	'tasks' => $controller->renderSingleTask($task),
	'data' => array(),
	);

	return id(new AphrontAjaxResponse())->setContent($payload);
	}

	private function buildCardResponse(ManiphestTask $task) {
	$controller = $this->getController();
	$request = $controller->getRequest();
	$viewer = $request->getViewer();

	$column_phid = $request->getStr('columnPHID');

	$visible_phids = $request->getStrList('visiblePHIDs');
	if (!$visible_phids) {
	$visible_phids = array();
	}

	$column = id(new PhabricatorProjectColumnQuery())
	->setViewer($viewer)
	->withPHIDs(array($column_phid))
	->executeOne();
	if (!$column) {
	return new Aphront404Response();
	}

	$board_phid = $column->getProjectPHID();
	$object_phid = $task->getPHID();

	return id(new PhabricatorBoardResponseEngine())
	->setViewer($viewer)
	->setBoardPHID($board_phid)
	->setObjectPHID($object_phid)
	->setVisiblePHIDs($visible_phids)
	->buildResponse();
	}

	private function getColumnMap(ManiphestTask $task) {
	$phid = $task->getPHID();
	if (!$phid) {
	return array();
	}

	$board_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$phid,
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST);
	if (!$board_phids) {
	return array();
	}

	$viewer = $this->getViewer();

	$layout_engine = id(new PhabricatorBoardLayoutEngine())
	->setViewer($viewer)
	->setBoardPHIDs($board_phids)
	->setObjectPHIDs(array($task->getPHID()))
	->executeLayout();

	$map = array();
	foreach ($board_phids as $board_phid) {
	$in_columns = $layout_engine->getObjectColumns($board_phid, $phid);
	$in_columns = mpull($in_columns, null, 'getPHID');

	$all_columns = $layout_engine->getColumns($board_phid);
	if (!$all_columns) {
	// This could be a project with no workboard, or a project the viewer
	// does not have permission to see.
	continue;
	}

	$board = head($all_columns)->getProject();

	$options = array();
	foreach ($all_columns as $column) {
	$name = $column->getDisplayName();

	$is_hidden = $column->isHidden();
	$is_selected = isset($in_columns[$column->getPHID()]);

	// Don't show hidden, subproject or milestone columns in this map
	// unless the object is currently in the column.
	$skip_column = ($is_hidden \|\| $column->getProxyPHID());
	if ($skip_column) {
	if (!$is_selected) {
	continue;
	}
	}

	if ($is_hidden) {
	$name = pht('(%s)', $name);
	}

	if ($is_selected) {
	$name = pht("\xE2\x97\x8F %s", $name);
	} else {
	$name = pht("\xE2\x97\x8B %s", $name);
	}

	$option = array(
	'key' => $column->getPHID(),
	'label' => $name,
	'selected' => (bool)$is_selected,
	);

	$options[] = $option;
	}

	$map[] = array(
	'label' => $board->getDisplayName(),
	'options' => $options,
	);
	}

	$map = isort($map, 'label');
	$map = array_values($map);

	return $map;
	}


	}
	diff --git a/src/applications/transactions/editengine/PhabricatorEditEngine.php b/src/applications/transactions/editengine/PhabricatorEditEngine.php
	index 63ccde3afd..4a0d109590 100644
	--- a/src/applications/transactions/editengine/PhabricatorEditEngine.php
	+++ b/src/applications/transactions/editengine/PhabricatorEditEngine.php
	@@ -1,2562 +1,2560 @@
	<?php


	/**
	* @task fields Managing Fields
	* @task text Display Text
	* @task config Edit Engine Configuration
	* @task uri Managing URIs
	* @task load Creating and Loading Objects
	* @task web Responding to Web Requests
	* @task edit Responding to Edit Requests
	* @task http Responding to HTTP Parameter Requests
	* @task conduit Responding to Conduit Requests
	*/
	abstract class PhabricatorEditEngine
	extends Phobject
	implements PhabricatorPolicyInterface {

	const EDITENGINECONFIG_DEFAULT = 'default';

	const SUBTYPE_DEFAULT = 'default';

	private $viewer;
	private $controller;
	private $isCreate;
	private $editEngineConfiguration;
	private $contextParameters = array();
	private $targetObject;
	private $page;
	private $pages;
	private $navigation;

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

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

	final public function setController(PhabricatorController $controller) {
	$this->controller = $controller;
	$this->setViewer($controller->getViewer());
	return $this;
	}

	final public function getController() {
	return $this->controller;
	}

	final public function getEngineKey() {
	$key = $this->getPhobjectClassConstant('ENGINECONST', 64);
	if (strpos($key, '/') !== false) {
	throw new Exception(
	pht(
	'EditEngine ("%s") contains an invalid key character "/".',
	get_class($this)));
	}
	return $key;
	}

	final public function getApplication() {
	$app_class = $this->getEngineApplicationClass();
	return PhabricatorApplication::getByClass($app_class);
	}

	final public function addContextParameter($key) {
	$this->contextParameters[] = $key;
	return $this;
	}

	public function isEngineConfigurable() {
	return true;
	}

	public function isEngineExtensible() {
	return true;
	}

	public function isDefaultQuickCreateEngine() {
	return false;
	}

	public function getDefaultQuickCreateFormKeys() {
	$keys = array();

	if ($this->isDefaultQuickCreateEngine()) {
	$keys[] = self::EDITENGINECONFIG_DEFAULT;
	}

	foreach ($keys as $idx => $key) {
	$keys[$idx] = $this->getEngineKey().'/'.$key;
	}

	return $keys;
	}

	public static function splitFullKey($full_key) {
	return explode('/', $full_key, 2);
	}

	public function getQuickCreateOrderVector() {
	return id(new PhutilSortVector())
	->addString($this->getObjectCreateShortText());
	}

	/**
	* Force the engine to edit a particular object.
	*/
	public function setTargetObject($target_object) {
	$this->targetObject = $target_object;
	return $this;
	}

	public function getTargetObject() {
	return $this->targetObject;
	}

	public function setNavigation(AphrontSideNavFilterView $navigation) {
	$this->navigation = $navigation;
	return $this;
	}

	public function getNavigation() {
	return $this->navigation;
	}


	/* -( Managing Fields )---------------------------------------------------- */


	abstract public function getEngineApplicationClass();
	abstract protected function buildCustomEditFields($object);

	public function getFieldsForConfig(
	PhabricatorEditEngineConfiguration $config) {

	$object = $this->newEditableObject();

	$this->editEngineConfiguration = $config;

	// This is mostly making sure that we fill in default values.
	$this->setIsCreate(true);

	return $this->buildEditFields($object);
	}

	final protected function buildEditFields($object) {
	$viewer = $this->getViewer();

	$fields = $this->buildCustomEditFields($object);

	foreach ($fields as $field) {
	$field
	->setViewer($viewer)
	->setObject($object);
	}

	$fields = mpull($fields, null, 'getKey');

	if ($this->isEngineExtensible()) {
	$extensions = PhabricatorEditEngineExtension::getAllEnabledExtensions();
	} else {
	$extensions = array();
	}

	foreach ($extensions as $extension) {
	$extension->setViewer($viewer);

	if (!$extension->supportsObject($this, $object)) {
	continue;
	}

	$extension_fields = $extension->buildCustomEditFields($this, $object);

	// TODO: Validate this in more detail with a more tailored error.
	assert_instances_of($extension_fields, 'PhabricatorEditField');

	foreach ($extension_fields as $field) {
	$field
	->setViewer($viewer)
	->setObject($object);
	}

	$extension_fields = mpull($extension_fields, null, 'getKey');

	foreach ($extension_fields as $key => $field) {
	$fields[$key] = $field;
	}
	}

	$config = $this->getEditEngineConfiguration();
	$fields = $this->willConfigureFields($object, $fields);
	$fields = $config->applyConfigurationToFields($this, $object, $fields);

	$fields = $this->applyPageToFields($object, $fields);

	return $fields;
	}

	protected function willConfigureFields($object, array $fields) {
	return $fields;
	}

	final public function supportsSubtypes() {
	try {
	$object = $this->newEditableObject();
	} catch (Exception $ex) {
	return false;
	}

	return ($object instanceof PhabricatorEditEngineSubtypeInterface);
	}

	final public function newSubtypeMap() {
	return $this->newEditableObject()->newEditEngineSubtypeMap();
	}


	/* -( Display Text )------------------------------------------------------- */


	/**
	* @task text
	*/
	abstract public function getEngineName();


	/**
	* @task text
	*/
	abstract protected function getObjectCreateTitleText($object);

	/**
	* @task text
	*/
	protected function getFormHeaderText($object) {
	$config = $this->getEditEngineConfiguration();
	return $config->getName();
	}

	/**
	* @task text
	*/
	abstract protected function getObjectEditTitleText($object);


	/**
	* @task text
	*/
	abstract protected function getObjectCreateShortText();


	/**
	* @task text
	*/
	abstract protected function getObjectName();


	/**
	* @task text
	*/
	abstract protected function getObjectEditShortText($object);


	/**
	* @task text
	*/
	protected function getObjectCreateButtonText($object) {
	return $this->getObjectCreateTitleText($object);
	}


	/**
	* @task text
	*/
	protected function getObjectEditButtonText($object) {
	return pht('Save Changes');
	}


	/**
	* @task text
	*/
	protected function getCommentViewSeriousHeaderText($object) {
	return pht('Take Action');
	}


	/**
	* @task text
	*/
	protected function getCommentViewSeriousButtonText($object) {
	return pht('Submit');
	}


	/**
	* @task text
	*/
	protected function getCommentViewHeaderText($object) {
	return $this->getCommentViewSeriousHeaderText($object);
	}


	/**
	* @task text
	*/
	protected function getCommentViewButtonText($object) {
	return $this->getCommentViewSeriousButtonText($object);
	}


	/**
	* @task text
	*/
	protected function getPageHeader($object) {
	return null;
	}



	/**
	* Return a human-readable header describing what this engine is used to do,
	* like "Configure Maniphest Task Forms".
	*
	* @return string Human-readable description of the engine.
	* @task text
	*/
	abstract public function getSummaryHeader();


	/**
	* Return a human-readable summary of what this engine is used to do.
	*
	* @return string Human-readable description of the engine.
	* @task text
	*/
	abstract public function getSummaryText();




	/* -( Edit Engine Configuration )------------------------------------------ */


	protected function supportsEditEngineConfiguration() {
	return true;
	}

	final protected function getEditEngineConfiguration() {
	return $this->editEngineConfiguration;
	}

	private function newConfigurationQuery() {
	return id(new PhabricatorEditEngineConfigurationQuery())
	->setViewer($this->getViewer())
	->withEngineKeys(array($this->getEngineKey()));
	}

	private function loadEditEngineConfigurationWithQuery(
	PhabricatorEditEngineConfigurationQuery $query,
	$sort_method) {

	if ($sort_method) {
	$results = $query->execute();
	$results = msort($results, $sort_method);
	$result = head($results);
	} else {
	$result = $query->executeOne();
	}

	if (!$result) {
	return null;
	}

	$this->editEngineConfiguration = $result;
	return $result;
	}

	private function loadEditEngineConfigurationWithIdentifier($identifier) {
	$query = $this->newConfigurationQuery()
	->withIdentifiers(array($identifier));

	return $this->loadEditEngineConfigurationWithQuery($query, null);
	}

	private function loadDefaultConfiguration() {
	$query = $this->newConfigurationQuery()
	->withIdentifiers(
	array(
	self::EDITENGINECONFIG_DEFAULT,
	))
	->withIgnoreDatabaseConfigurations(true);

	return $this->loadEditEngineConfigurationWithQuery($query, null);
	}

	private function loadDefaultCreateConfiguration() {
	$query = $this->newConfigurationQuery()
	->withIsDefault(true)
	->withIsDisabled(false);

	return $this->loadEditEngineConfigurationWithQuery(
	$query,
	'getCreateSortKey');
	}

	public function loadDefaultEditConfiguration($object) {
	$query = $this->newConfigurationQuery()
	->withIsEdit(true)
	->withIsDisabled(false);

	// If this object supports subtyping, we edit it with a form of the same
	// subtype: so "bug" tasks get edited with "bug" forms.
	if ($object instanceof PhabricatorEditEngineSubtypeInterface) {
	$query->withSubtypes(
	array(
	$object->getEditEngineSubtype(),
	));
	}

	return $this->loadEditEngineConfigurationWithQuery(
	$query,
	'getEditSortKey');
	}

	final public function getBuiltinEngineConfigurations() {
	$configurations = $this->newBuiltinEngineConfigurations();

	if (!$configurations) {
	throw new Exception(
	pht(
	'EditEngine ("%s") returned no builtin engine configurations, but '.
	'an edit engine must have at least one configuration.',
	get_class($this)));
	}

	assert_instances_of($configurations, 'PhabricatorEditEngineConfiguration');

	$has_default = false;
	foreach ($configurations as $config) {
	if ($config->getBuiltinKey() == self::EDITENGINECONFIG_DEFAULT) {
	$has_default = true;
	}
	}

	if (!$has_default) {
	$first = head($configurations);
	if (!$first->getBuiltinKey()) {
	$first
	->setBuiltinKey(self::EDITENGINECONFIG_DEFAULT)
	->setIsDefault(true)
	->setIsEdit(true);

	if (!strlen($first->getName())) {
	$first->setName($this->getObjectCreateShortText());
	}
	} else {
	throw new Exception(
	pht(
	'EditEngine ("%s") returned builtin engine configurations, '.
	'but none are marked as default and the first configuration has '.
	'a different builtin key already. Mark a builtin as default or '.
	'omit the key from the first configuration',
	get_class($this)));
	}
	}

	$builtins = array();
	foreach ($configurations as $key => $config) {
	$builtin_key = $config->getBuiltinKey();

	if ($builtin_key === null) {
	throw new Exception(
	pht(
	'EditEngine ("%s") returned builtin engine configurations, '.
	'but one (with key "%s") is missing a builtin key. Provide a '.
	'builtin key for each configuration (you can omit it from the '.
	'first configuration in the list to automatically assign the '.
	'default key).',
	get_class($this),
	$key));
	}

	if (isset($builtins[$builtin_key])) {
	throw new Exception(
	pht(
	'EditEngine ("%s") returned builtin engine configurations, '.
	'but at least two specify the same builtin key ("%s"). Engines '.
	'must have unique builtin keys.',
	get_class($this),
	$builtin_key));
	}

	$builtins[$builtin_key] = $config;
	}


	return $builtins;
	}

	protected function newBuiltinEngineConfigurations() {
	return array(
	$this->newConfiguration(),
	);
	}

	final protected function newConfiguration() {
	return PhabricatorEditEngineConfiguration::initializeNewConfiguration(
	$this->getViewer(),
	$this);
	}


	/* -( Managing URIs )------------------------------------------------------ */


	/**
	* @task uri
	*/
	abstract protected function getObjectViewURI($object);


	/**
	* @task uri
	*/
	protected function getObjectCreateCancelURI($object) {
	return $this->getApplication()->getApplicationURI();
	}


	/**
	* @task uri
	*/
	protected function getEditorURI() {
	return $this->getApplication()->getApplicationURI('edit/');
	}


	/**
	* @task uri
	*/
	protected function getObjectEditCancelURI($object) {
	return $this->getObjectViewURI($object);
	}


	/**
	* @task uri
	*/
	public function getEditURI($object = null, $path = null) {
	$parts = array();

	$parts[] = $this->getEditorURI();

	if ($object && $object->getID()) {
	$parts[] = $object->getID().'/';
	}

	if ($path !== null) {
	$parts[] = $path;
	}

	return implode('', $parts);
	}

	public function getEffectiveObjectViewURI($object) {
	if ($this->getIsCreate()) {
	return $this->getObjectViewURI($object);
	}

	$page = $this->getSelectedPage();
	if ($page) {
	$view_uri = $page->getViewURI();
	if ($view_uri !== null) {
	return $view_uri;
	}
	}

	return $this->getObjectViewURI($object);
	}

	public function getEffectiveObjectEditDoneURI($object) {
	return $this->getEffectiveObjectViewURI($object);
	}

	public function getEffectiveObjectEditCancelURI($object) {
	$page = $this->getSelectedPage();
	if ($page) {
	$view_uri = $page->getViewURI();
	if ($view_uri !== null) {
	return $view_uri;
	}
	}

	return $this->getObjectEditCancelURI($object);
	}


	/* -( Creating and Loading Objects )--------------------------------------- */


	/**
	* Initialize a new object for creation.
	*
	* @return object Newly initialized object.
	* @task load
	*/
	abstract protected function newEditableObject();


	/**
	* Build an empty query for objects.
	*
	* @return PhabricatorPolicyAwareQuery Query.
	* @task load
	*/
	abstract protected function newObjectQuery();


	/**
	* Test if this workflow is creating a new object or editing an existing one.
	*
	* @return bool True if a new object is being created.
	* @task load
	*/
	final public function getIsCreate() {
	return $this->isCreate;
	}

	/**
	* Initialize a new object for object creation via Conduit.
	*
	* @return object Newly initialized object.
	* @param list<wild> Raw transactions.
	* @task load
	*/
	protected function newEditableObjectFromConduit(array $raw_xactions) {
	return $this->newEditableObject();
	}

	/**
	* Initialize a new object for documentation creation.
	*
	* @return object Newly initialized object.
	* @task load
	*/
	protected function newEditableObjectForDocumentation() {
	return $this->newEditableObject();
	}

	/**
	* Flag this workflow as a create or edit.
	*
	* @param bool True if this is a create workflow.
	* @return this
	* @task load
	*/
	private function setIsCreate($is_create) {
	$this->isCreate = $is_create;
	return $this;
	}


	/**
	* Try to load an object by ID, PHID, or monogram. This is done primarily
	* to make Conduit a little easier to use.
	*
	* @param wild ID, PHID, or monogram.
	* @param list<const> List of required capability constants, or omit for
	* defaults.
	* @return object Corresponding editable object.
	* @task load
	*/
	private function newObjectFromIdentifier(
	$identifier,
	array $capabilities = array()) {
	if (is_int($identifier) \|\| ctype_digit($identifier)) {
	$object = $this->newObjectFromID($identifier, $capabilities);

	if (!$object) {
	throw new Exception(
	pht(
	'No object exists with ID "%s".',
	$identifier));
	}

	return $object;
	}

	$type_unknown = PhabricatorPHIDConstants::PHID_TYPE_UNKNOWN;
	if (phid_get_type($identifier) != $type_unknown) {
	$object = $this->newObjectFromPHID($identifier, $capabilities);

	if (!$object) {
	throw new Exception(
	pht(
	'No object exists with PHID "%s".',
	$identifier));
	}

	return $object;
	}

	$target = id(new PhabricatorObjectQuery())
	->setViewer($this->getViewer())
	->withNames(array($identifier))
	->executeOne();
	if (!$target) {
	throw new Exception(
	pht(
	'Monogram "%s" does not identify a valid object.',
	$identifier));
	}

	$expect = $this->newEditableObject();
	$expect_class = get_class($expect);
	$target_class = get_class($target);
	if ($expect_class !== $target_class) {
	throw new Exception(
	pht(
	'Monogram "%s" identifies an object of the wrong type. Loaded '.
	'object has class "%s", but this editor operates on objects of '.
	'type "%s".',
	$identifier,
	$target_class,
	$expect_class));
	}

	// Load the object by PHID using this engine's standard query. This makes
	// sure it's really valid, goes through standard policy check logic, and
	// picks up any `need...()` clauses we want it to load with.

	$object = $this->newObjectFromPHID($target->getPHID(), $capabilities);
	if (!$object) {
	throw new Exception(
	pht(
	'Failed to reload object identified by monogram "%s" when '.
	'querying by PHID.',
	$identifier));
	}

	return $object;
	}

	/**
	* Load an object by ID.
	*
	* @param int Object ID.
	* @param list<const> List of required capability constants, or omit for
	* defaults.
	* @return object\|null Object, or null if no such object exists.
	* @task load
	*/
	private function newObjectFromID($id, array $capabilities = array()) {
	$query = $this->newObjectQuery()
	->withIDs(array($id));

	return $this->newObjectFromQuery($query, $capabilities);
	}


	/**
	* Load an object by PHID.
	*
	* @param phid Object PHID.
	* @param list<const> List of required capability constants, or omit for
	* defaults.
	* @return object\|null Object, or null if no such object exists.
	* @task load
	*/
	private function newObjectFromPHID($phid, array $capabilities = array()) {
	$query = $this->newObjectQuery()
	->withPHIDs(array($phid));

	return $this->newObjectFromQuery($query, $capabilities);
	}


	/**
	* Load an object given a configured query.
	*
	* @param PhabricatorPolicyAwareQuery Configured query.
	* @param list<const> List of required capability constants, or omit for
	* defaults.
	* @return object\|null Object, or null if no such object exists.
	* @task load
	*/
	private function newObjectFromQuery(
	PhabricatorPolicyAwareQuery $query,
	array $capabilities = array()) {

	$viewer = $this->getViewer();

	if (!$capabilities) {
	$capabilities = array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	);
	}

	$object = $query
	->setViewer($viewer)
	->requireCapabilities($capabilities)
	->executeOne();
	if (!$object) {
	return null;
	}

	return $object;
	}


	/**
	* Verify that an object is appropriate for editing.
	*
	* @param wild Loaded value.
	* @return void
	* @task load
	*/
	private function validateObject($object) {
	if (!$object \|\| !is_object($object)) {
	throw new Exception(
	pht(
	'EditEngine "%s" created or loaded an invalid object: object must '.
	'actually be an object, but is of some other type ("%s").',
	get_class($this),
	gettype($object)));
	}

	if (!($object instanceof PhabricatorApplicationTransactionInterface)) {
	throw new Exception(
	pht(
	'EditEngine "%s" created or loaded an invalid object: object (of '.
	'class "%s") must implement "%s", but does not.',
	get_class($this),
	get_class($object),
	'PhabricatorApplicationTransactionInterface'));
	}
	}


	/* -( Responding to Web Requests )----------------------------------------- */


	final public function buildResponse() {
	$viewer = $this->getViewer();
	$controller = $this->getController();
	$request = $controller->getRequest();

	$action = $this->getEditAction();

	$capabilities = array();
	$use_default = false;
	$require_create = true;
	switch ($action) {
	case 'comment':
	$capabilities = array(
	PhabricatorPolicyCapability::CAN_VIEW,
	);
	$use_default = true;
	break;
	case 'parameters':
	$use_default = true;
	break;
	case 'nodefault':
	case 'nocreate':
	case 'nomanage':
	$require_create = false;
	break;
	default:
	break;
	}

	$object = $this->getTargetObject();
	if (!$object) {
	$id = $request->getURIData('id');

	if ($id) {
	$this->setIsCreate(false);
	$object = $this->newObjectFromID($id, $capabilities);
	if (!$object) {
	return new Aphront404Response();
	}
	} else {
	// Make sure the viewer has permission to create new objects of
	// this type if we're going to create a new object.
	if ($require_create) {
	$this->requireCreateCapability();
	}

	$this->setIsCreate(true);
	$object = $this->newEditableObject();
	}
	} else {
	$id = $object->getID();
	}

	$this->validateObject($object);

	if ($use_default) {
	$config = $this->loadDefaultConfiguration();
	if (!$config) {
	return new Aphront404Response();
	}
	} else {
	$form_key = $request->getURIData('formKey');
	if (strlen($form_key)) {
	$config = $this->loadEditEngineConfigurationWithIdentifier($form_key);

	if (!$config) {
	return new Aphront404Response();
	}

	if ($id && !$config->getIsEdit()) {
	return $this->buildNotEditFormRespose($object, $config);
	}
	} else {
	if ($id) {
	$config = $this->loadDefaultEditConfiguration($object);
	if (!$config) {
	return $this->buildNoEditResponse($object);
	}
	} else {
	$config = $this->loadDefaultCreateConfiguration();
	if (!$config) {
	return $this->buildNoCreateResponse($object);
	}
	}
	}
	}

	if ($config->getIsDisabled()) {
	return $this->buildDisabledFormResponse($object, $config);
	}

	$page_key = $request->getURIData('pageKey');
	if (!strlen($page_key)) {
	$pages = $this->getPages($object);
	if ($pages) {
	$page_key = head_key($pages);
	}
	}

	if (strlen($page_key)) {
	$page = $this->selectPage($object, $page_key);
	if (!$page) {
	return new Aphront404Response();
	}
	}

	switch ($action) {
	case 'parameters':
	return $this->buildParametersResponse($object);
	case 'nodefault':
	return $this->buildNoDefaultResponse($object);
	case 'nocreate':
	return $this->buildNoCreateResponse($object);
	case 'nomanage':
	return $this->buildNoManageResponse($object);
	case 'comment':
	return $this->buildCommentResponse($object);
	default:
	return $this->buildEditResponse($object);
	}
	}

	private function buildCrumbs($object, $final = false) {
	$controller = $this->getController();

	$crumbs = $controller->buildApplicationCrumbsForEditEngine();
	if ($this->getIsCreate()) {
	$create_text = $this->getObjectCreateShortText();
	if ($final) {
	$crumbs->addTextCrumb($create_text);
	} else {
	$edit_uri = $this->getEditURI($object);
	$crumbs->addTextCrumb($create_text, $edit_uri);
	}
	} else {
	$crumbs->addTextCrumb(
	$this->getObjectEditShortText($object),
	$this->getEffectiveObjectViewURI($object));

	$edit_text = pht('Edit');
	if ($final) {
	$crumbs->addTextCrumb($edit_text);
	} else {
	$edit_uri = $this->getEditURI($object);
	$crumbs->addTextCrumb($edit_text, $edit_uri);
	}
	}

	return $crumbs;
	}

	private function buildEditResponse($object) {
	$viewer = $this->getViewer();
	$controller = $this->getController();
	$request = $controller->getRequest();

	$fields = $this->buildEditFields($object);
	$template = $object->getApplicationTransactionTemplate();

	if ($this->getIsCreate()) {
	$cancel_uri = $this->getObjectCreateCancelURI($object);
	$submit_button = $this->getObjectCreateButtonText($object);
	} else {
	$cancel_uri = $this->getEffectiveObjectEditCancelURI($object);
	$submit_button = $this->getObjectEditButtonText($object);
	}

	$config = $this->getEditEngineConfiguration()
	->attachEngine($this);

	// NOTE: Don't prompt users to override locks when creating objects,
	// even if the default settings would create a locked object.

	$can_interact = PhabricatorPolicyFilter::canInteract($viewer, $object);
	if (!$can_interact &&
	!$this->getIsCreate() &&
	!$request->getBool('editEngine') &&
	!$request->getBool('overrideLock')) {

	$lock = PhabricatorEditEngineLock::newForObject($viewer, $object);

	$dialog = $this->getController()
	->newDialog()
	->addHiddenInput('overrideLock', true)
	->setDisableWorkflowOnSubmit(true)
	->addCancelButton($cancel_uri);

	return $lock->willPromptUserForLockOverrideWithDialog($dialog);
	}

	$validation_exception = null;
	if ($request->isFormPost() && $request->getBool('editEngine')) {
	$submit_fields = $fields;

	foreach ($submit_fields as $key => $field) {
	if (!$field->shouldGenerateTransactionsFromSubmit()) {
	unset($submit_fields[$key]);
	continue;
	}
	}

	// Before we read the submitted values, store a copy of what we would
	// use if the form was empty so we can figure out which transactions are
	// just setting things to their default values for the current form.
	$defaults = array();
	foreach ($submit_fields as $key => $field) {
	$defaults[$key] = $field->getValueForTransaction();
	}

	foreach ($submit_fields as $key => $field) {
	$field->setIsSubmittedForm(true);

	if (!$field->shouldReadValueFromSubmit()) {
	continue;
	}

	$field->readValueFromSubmit($request);
	}

	$xactions = array();

	if ($this->getIsCreate()) {
	$xactions[] = id(clone $template)
	->setTransactionType(PhabricatorTransactions::TYPE_CREATE);

	if ($this->supportsSubtypes()) {
	$xactions[] = id(clone $template)
	->setTransactionType(PhabricatorTransactions::TYPE_SUBTYPE)
	->setNewValue($config->getSubtype());
	}
	}

	foreach ($submit_fields as $key => $field) {
	$field_value = $field->getValueForTransaction();

	$type_xactions = $field->generateTransactions(
	clone $template,
	array(
	'value' => $field_value,
	));

	foreach ($type_xactions as $type_xaction) {
	$default = $defaults[$key];

	if ($default === $field->getValueForTransaction()) {
	$type_xaction->setIsDefaultTransaction(true);
	}

	$xactions[] = $type_xaction;
	}
	}

	$editor = $object->getApplicationTransactionEditor()
	->setActor($viewer)
	->setContentSourceFromRequest($request)
	->setContinueOnNoEffect(true);

	try {
	$xactions = $this->willApplyTransactions($object, $xactions);

	$editor->applyTransactions($object, $xactions);

	$this->didApplyTransactions($object, $xactions);

	return $this->newEditResponse($request, $object, $xactions);
	} catch (PhabricatorApplicationTransactionValidationException $ex) {
	$validation_exception = $ex;

	foreach ($fields as $field) {
	$message = $this->getValidationExceptionShortMessage($ex, $field);
	if ($message === null) {
	continue;
	}

	$field->setControlError($message);
	}
	}
	} else {
	if ($this->getIsCreate()) {
	$template = $request->getStr('template');

	if (strlen($template)) {
	$template_object = $this->newObjectFromIdentifier(
	$template,
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	));
	if (!$template_object) {
	return new Aphront404Response();
	}
	} else {
	$template_object = null;
	}

	if ($template_object) {
	$copy_fields = $this->buildEditFields($template_object);
	$copy_fields = mpull($copy_fields, null, 'getKey');
	foreach ($copy_fields as $copy_key => $copy_field) {
	if (!$copy_field->getIsCopyable()) {
	unset($copy_fields[$copy_key]);
	}
	}
	} else {
	$copy_fields = array();
	}

	foreach ($fields as $field) {
	if (!$field->shouldReadValueFromRequest()) {
	continue;
	}

	$field_key = $field->getKey();
	if (isset($copy_fields[$field_key])) {
	$field->readValueFromField($copy_fields[$field_key]);
	}

	$field->readValueFromRequest($request);
	}
	}
	}

	$action_button = $this->buildEditFormActionButton($object);

	if ($this->getIsCreate()) {
	$header_text = $this->getFormHeaderText($object);
	} else {
	$header_text = $this->getObjectEditTitleText($object);
	}

	$show_preview = !$request->isAjax();

	if ($show_preview) {
	$previews = array();
	foreach ($fields as $field) {
	$preview = $field->getPreviewPanel();
	if (!$preview) {
	continue;
	}

	$control_id = $field->getControlID();

	$preview
	->setControlID($control_id)
	->setPreviewURI('/transactions/remarkuppreview/');

	$previews[] = $preview;
	}
	} else {
	$previews = array();
	}

	$form = $this->buildEditForm($object, $fields);

	$crumbs = $this->buildCrumbs($object, $final = true);
	$crumbs->setBorder(true);

	if ($request->isAjax()) {
	return $this->getController()
	->newDialog()
	->setWidth(AphrontDialogView::WIDTH_FULL)
	->setTitle($header_text)
	->setValidationException($validation_exception)
	->appendForm($form)
	->addCancelButton($cancel_uri)
	->addSubmitButton($submit_button);
	}

	$box_header = id(new PHUIHeaderView())
	->setHeader($header_text);

	if ($action_button) {
	$box_header->addActionLink($action_button);
	}

	$box = id(new PHUIObjectBoxView())
	->setUser($viewer)
	->setHeader($box_header)
	->setValidationException($validation_exception)
	->setBackground(PHUIObjectBoxView::WHITE_CONFIG)
	->appendChild($form);

	// This is fairly questionable, but in use by Settings.
	if ($request->getURIData('formSaved')) {
	$box->setFormSaved(true);
	}

	$content = array(
	$box,
	$previews,
	);

	$view = new PHUITwoColumnView();

	$page_header = $this->getPageHeader($object);
	if ($page_header) {
	$view->setHeader($page_header);
	}

	$page = $controller->newPage()
	->setTitle($header_text)
	->setCrumbs($crumbs)
	->appendChild($view);

	$navigation = $this->getNavigation();
	if ($navigation) {
	$view->setFixed(true);
	$view->setNavigation($navigation);
	$view->setMainColumn($content);
	} else {
	$view->setFooter($content);
	}

	return $page;
	}

	protected function newEditResponse(
	AphrontRequest $request,
	$object,
	array $xactions) {
	return id(new AphrontRedirectResponse())
	->setURI($this->getEffectiveObjectEditDoneURI($object));
	}

	private function buildEditForm($object, array $fields) {
	$viewer = $this->getViewer();
	$controller = $this->getController();
	$request = $controller->getRequest();

	$fields = $this->willBuildEditForm($object, $fields);

	$form = id(new AphrontFormView())
	->setUser($viewer)
	->addHiddenInput('editEngine', 'true');

	foreach ($this->contextParameters as $param) {
	$form->addHiddenInput($param, $request->getStr($param));
	}

	foreach ($fields as $field) {
	$field->appendToForm($form);
	}

	if ($this->getIsCreate()) {
	$cancel_uri = $this->getObjectCreateCancelURI($object);
	$submit_button = $this->getObjectCreateButtonText($object);
	} else {
	$cancel_uri = $this->getEffectiveObjectEditCancelURI($object);
	$submit_button = $this->getObjectEditButtonText($object);
	}

	if (!$request->isAjax()) {
	$buttons = id(new AphrontFormSubmitControl())
	->setValue($submit_button);

	if ($cancel_uri) {
	$buttons->addCancelButton($cancel_uri);
	}

	$form->appendControl($buttons);
	}

	return $form;
	}

	protected function willBuildEditForm($object, array $fields) {
	return $fields;
	}

	private function buildEditFormActionButton($object) {
	if (!$this->isEngineConfigurable()) {
	return null;
	}

	$viewer = $this->getViewer();

	$action_view = id(new PhabricatorActionListView())
	->setUser($viewer);

	foreach ($this->buildEditFormActions($object) as $action) {
	$action_view->addAction($action);
	}

	$action_button = id(new PHUIButtonView())
	->setTag('a')
	->setText(pht('Configure Form'))
	->setHref('#')
	->setIcon('fa-gear')
	->setDropdownMenu($action_view);

	return $action_button;
	}

	private function buildEditFormActions($object) {
	$actions = array();

	if ($this->supportsEditEngineConfiguration()) {
	$engine_key = $this->getEngineKey();
	$config = $this->getEditEngineConfiguration();

	$can_manage = PhabricatorPolicyFilter::hasCapability(
	$this->getViewer(),
	$config,
	PhabricatorPolicyCapability::CAN_EDIT);

	if ($can_manage) {
	$manage_uri = $config->getURI();
	} else {
	$manage_uri = $this->getEditURI(null, 'nomanage/');
	}

	$view_uri = "/transactions/editengine/{$engine_key}/";

	$actions[] = id(new PhabricatorActionView())
	->setLabel(true)
	->setName(pht('Configuration'));

	$actions[] = id(new PhabricatorActionView())
	->setName(pht('View Form Configurations'))
	->setIcon('fa-list-ul')
	->setHref($view_uri);

	$actions[] = id(new PhabricatorActionView())
	->setName(pht('Edit Form Configuration'))
	->setIcon('fa-pencil')
	->setHref($manage_uri)
	->setDisabled(!$can_manage)
	->setWorkflow(!$can_manage);
	}

	$actions[] = id(new PhabricatorActionView())
	->setLabel(true)
	->setName(pht('Documentation'));

	$actions[] = id(new PhabricatorActionView())
	->setName(pht('Using HTTP Parameters'))
	->setIcon('fa-book')
	->setHref($this->getEditURI($object, 'parameters/'));

	$doc_href = PhabricatorEnv::getDoclink('User Guide: Customizing Forms');
	$actions[] = id(new PhabricatorActionView())
	->setName(pht('User Guide: Customizing Forms'))
	->setIcon('fa-book')
	->setHref($doc_href);

	return $actions;
	}


	/**
	* Test if the viewer could apply a certain type of change by using the
	* normal "Edit" form.
	*
	* This method returns `true` if the user has access to an edit form and
	* that edit form has a field which applied the specified transaction type,
	* and that field is visible and editable for the user.
	*
	* For example, you can use it to test if a user is able to reassign tasks
	* or not, prior to rendering dedicated UI for task reassignment.
	*
	* Note that this method does NOT test if the user can actually edit the
	* current object, just if they have access to the related field.
	*
	* @param const Transaction type to test for.
	* @return bool True if the user could "Edit" to apply the transaction type.
	*/
	final public function hasEditAccessToTransaction($xaction_type) {
	$viewer = $this->getViewer();

	$object = $this->getTargetObject();
	if (!$object) {
	$object = $this->newEditableObject();
	}

	$config = $this->loadDefaultEditConfiguration($object);
	if (!$config) {
	return false;
	}

	$fields = $this->buildEditFields($object);

	$field = null;
	foreach ($fields as $form_field) {
	$field_xaction_type = $form_field->getTransactionType();
	if ($field_xaction_type === $xaction_type) {
	$field = $form_field;
	break;
	}
	}

	if (!$field) {
	return false;
	}

	if (!$field->shouldReadValueFromSubmit()) {
	return false;
	}

	return true;
	}


	public function newNUXButton($text) {
	$specs = $this->newCreateActionSpecifications(array());
	$head = head($specs);

	return id(new PHUIButtonView())
	->setTag('a')
	->setText($text)
	->setHref($head['uri'])
	->setDisabled($head['disabled'])
	->setWorkflow($head['workflow'])
	->setColor(PHUIButtonView::GREEN);
	}


	final public function addActionToCrumbs(
	PHUICrumbsView $crumbs,
	array $parameters = array()) {
	$viewer = $this->getViewer();

	$specs = $this->newCreateActionSpecifications($parameters);

	$head = head($specs);
	$menu_uri = $head['uri'];

	$dropdown = null;
	if (count($specs) > 1) {
	$menu_icon = 'fa-caret-square-o-down';
	$menu_name = $this->getObjectCreateShortText();
	$workflow = false;
	$disabled = false;

	$dropdown = id(new PhabricatorActionListView())
	->setUser($viewer);

	foreach ($specs as $spec) {
	$dropdown->addAction(
	id(new PhabricatorActionView())
	->setName($spec['name'])
	->setIcon($spec['icon'])
	->setHref($spec['uri'])
	->setDisabled($head['disabled'])
	->setWorkflow($head['workflow']));
	}

	} else {
	$menu_icon = $head['icon'];
	$menu_name = $head['name'];

	$workflow = $head['workflow'];
	$disabled = $head['disabled'];
	}

	$action = id(new PHUIListItemView())
	->setName($menu_name)
	->setHref($menu_uri)
	->setIcon($menu_icon)
	->setWorkflow($workflow)
	->setDisabled($disabled);

	if ($dropdown) {
	$action->setDropdownMenu($dropdown);
	}

	$crumbs->addAction($action);
	}


	/**
	* Build a raw description of available "Create New Object" UI options so
	* other methods can build menus or buttons.
	*/
	public function newCreateActionSpecifications(array $parameters) {
	$viewer = $this->getViewer();

	$can_create = $this->hasCreateCapability();
	if ($can_create) {
	$configs = $this->loadUsableConfigurationsForCreate();
	} else {
	$configs = array();
	}

	$disabled = false;
	$workflow = false;

	$menu_icon = 'fa-plus-square';
	$specs = array();
	if (!$configs) {
	if ($viewer->isLoggedIn()) {
	$disabled = true;
	} else {
	// If the viewer isn't logged in, assume they'll get hit with a login
	// dialog and are likely able to create objects after they log in.
	$disabled = false;
	}
	$workflow = true;

	if ($can_create) {
	$create_uri = $this->getEditURI(null, 'nodefault/');
	} else {
	$create_uri = $this->getEditURI(null, 'nocreate/');
	}

	$specs[] = array(
	'name' => $this->getObjectCreateShortText(),
	'uri' => $create_uri,
	'icon' => $menu_icon,
	'disabled' => $disabled,
	'workflow' => $workflow,
	);
	} else {
	foreach ($configs as $config) {
	$config_uri = $config->getCreateURI();

	if ($parameters) {
	$config_uri = (string)id(new PhutilURI($config_uri))
	->setQueryParams($parameters);
	}

	$specs[] = array(
	'name' => $config->getDisplayName(),
	'uri' => $config_uri,
	'icon' => 'fa-plus',
	'disabled' => false,
	'workflow' => false,
	);
	}
	}

	return $specs;
	}

	final public function buildEditEngineCommentView($object) {
	$config = $this->loadDefaultEditConfiguration($object);

	if (!$config) {
	// TODO: This just nukes the entire comment form if you don't have access
	// to any edit forms. We might want to tailor this UX a bit.
	return id(new PhabricatorApplicationTransactionCommentView())
	->setNoPermission(true);
	}

	$viewer = $this->getViewer();

	$can_interact = PhabricatorPolicyFilter::canInteract($viewer, $object);
	if (!$can_interact) {
	$lock = PhabricatorEditEngineLock::newForObject($viewer, $object);

	return id(new PhabricatorApplicationTransactionCommentView())
	->setEditEngineLock($lock);
	}

	$object_phid = $object->getPHID();
	$is_serious = PhabricatorEnv::getEnvConfig('phabricator.serious-business');

	if ($is_serious) {
	$header_text = $this->getCommentViewSeriousHeaderText($object);
	$button_text = $this->getCommentViewSeriousButtonText($object);
	} else {
	$header_text = $this->getCommentViewHeaderText($object);
	$button_text = $this->getCommentViewButtonText($object);
	}

	$comment_uri = $this->getEditURI($object, 'comment/');

	$view = id(new PhabricatorApplicationTransactionCommentView())
	->setUser($viewer)
	->setObjectPHID($object_phid)
	->setHeaderText($header_text)
	->setAction($comment_uri)
	->setSubmitButtonName($button_text);

	$draft = PhabricatorVersionedDraft::loadDraft(
	$object_phid,
	$viewer->getPHID());
	if ($draft) {
	$view->setVersionedDraft($draft);
	}

	$view->setCurrentVersion($this->loadDraftVersion($object));

	$fields = $this->buildEditFields($object);

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

	$comment_actions = array();
	foreach ($fields as $field) {
	if (!$field->shouldGenerateTransactionsFromComment()) {
	continue;
	}

	if (!$can_edit) {
	if (!$field->getCanApplyWithoutEditCapability()) {
	continue;
	}
	}

	$comment_action = $field->getCommentAction();
	if (!$comment_action) {
	continue;
	}

	$key = $comment_action->getKey();

	// TODO: Validate these better.

	$comment_actions[$key] = $comment_action;
	}

	$comment_actions = msortv($comment_actions, 'getSortVector');

	$view->setCommentActions($comment_actions);

	$comment_groups = $this->newCommentActionGroups();
	$view->setCommentActionGroups($comment_groups);

	return $view;
	}

	protected function loadDraftVersion($object) {
	$viewer = $this->getViewer();

	if (!$viewer->isLoggedIn()) {
	return null;
	}

	$template = $object->getApplicationTransactionTemplate();
	$conn_r = $template->establishConnection('r');

	// Find the most recent transaction the user has written. We'll use this
	// as a version number to make sure that out-of-date drafts get discarded.
	$result = queryfx_one(
	$conn_r,
	'SELECT id AS version FROM %T
	WHERE objectPHID = %s AND authorPHID = %s
	ORDER BY id DESC LIMIT 1',
	$template->getTableName(),
	$object->getPHID(),
	$viewer->getPHID());

	if ($result) {
	return (int)$result['version'];
	} else {
	return null;
	}
	}


	/* -( Responding to HTTP Parameter Requests )------------------------------ */


	/**
	* Respond to a request for documentation on HTTP parameters.
	*
	* @param object Editable object.
	* @return AphrontResponse Response object.
	* @task http
	*/
	private function buildParametersResponse($object) {
	$controller = $this->getController();
	$viewer = $this->getViewer();
	$request = $controller->getRequest();
	$fields = $this->buildEditFields($object);

	$crumbs = $this->buildCrumbs($object);
	$crumbs->addTextCrumb(pht('HTTP Parameters'));
	$crumbs->setBorder(true);

	$header_text = pht(
	'HTTP Parameters: %s',
	$this->getObjectCreateShortText());

	$header = id(new PHUIHeaderView())
	->setHeader($header_text);

	$help_view = id(new PhabricatorApplicationEditHTTPParameterHelpView())
	->setUser($viewer)
	->setFields($fields);

	$document = id(new PHUIDocumentViewPro())
	->setUser($viewer)
	->setHeader($header)
	->appendChild($help_view);

	return $controller->newPage()
	->setTitle(pht('HTTP Parameters'))
	->setCrumbs($crumbs)
	->appendChild($document);
	}


	private function buildError($object, $title, $body) {
	$cancel_uri = $this->getObjectCreateCancelURI($object);

	$dialog = $this->getController()
	->newDialog()
	->addCancelButton($cancel_uri);

	if ($title !== null) {
	$dialog->setTitle($title);
	}

	if ($body !== null) {
	$dialog->appendParagraph($body);
	}

	return $dialog;
	}


	private function buildNoDefaultResponse($object) {
	return $this->buildError(
	$object,
	pht('No Default Create Forms'),
	pht(
	'This application is not configured with any forms for creating '.
	'objects that are visible to you and enabled.'));
	}

	private function buildNoCreateResponse($object) {
	return $this->buildError(
	$object,
	pht('No Create Permission'),
	pht('You do not have permission to create these objects.'));
	}

	private function buildNoManageResponse($object) {
	return $this->buildError(
	$object,
	pht('No Manage Permission'),
	pht(
	'You do not have permission to configure forms for this '.
	'application.'));
	}

	private function buildNoEditResponse($object) {
	return $this->buildError(
	$object,
	pht('No Edit Forms'),
	pht(
	'You do not have access to any forms which are enabled and marked '.
	'as edit forms.'));
	}

	private function buildNotEditFormRespose($object, $config) {
	return $this->buildError(
	$object,
	pht('Not an Edit Form'),
	pht(
	'This form ("%s") is not marked as an edit form, so '.
	'it can not be used to edit objects.',
	$config->getName()));
	}

	private function buildDisabledFormResponse($object, $config) {
	return $this->buildError(
	$object,
	pht('Form Disabled'),
	pht(
	'This form ("%s") has been disabled, so it can not be used.',
	$config->getName()));
	}

	private function buildLockedObjectResponse($object) {
	$dialog = $this->buildError($object, null, null);
	$viewer = $this->getViewer();

	$lock = PhabricatorEditEngineLock::newForObject($viewer, $object);
	return $lock->willBlockUserInteractionWithDialog($dialog);
	}

	private function buildCommentResponse($object) {
	$viewer = $this->getViewer();

	if ($this->getIsCreate()) {
	return new Aphront404Response();
	}

	$controller = $this->getController();
	$request = $controller->getRequest();

	if (!$request->isFormPost()) {
	return new Aphront400Response();
	}

	$can_interact = PhabricatorPolicyFilter::canInteract($viewer, $object);
	if (!$can_interact) {
	return $this->buildLockedObjectResponse($object);
	}

	$config = $this->loadDefaultEditConfiguration($object);
	if (!$config) {
	return new Aphront404Response();
	}

	$fields = $this->buildEditFields($object);

	$is_preview = $request->isPreviewRequest();
	$view_uri = $this->getEffectiveObjectViewURI($object);

	$template = $object->getApplicationTransactionTemplate();
	$comment_template = $template->getApplicationTransactionCommentObject();

	$comment_text = $request->getStr('comment');

	$actions = $request->getStr('editengine.actions');
	if ($actions) {
	$actions = phutil_json_decode($actions);
	}

	if ($is_preview) {
	$version_key = PhabricatorVersionedDraft::KEY_VERSION;
	$request_version = $request->getInt($version_key);
	$current_version = $this->loadDraftVersion($object);
	if ($request_version >= $current_version) {
	$draft = PhabricatorVersionedDraft::loadOrCreateDraft(
	$object->getPHID(),
	$viewer->getPHID(),
	$current_version);

	$is_empty = (!strlen($comment_text) && !$actions);

	$draft
	->setProperty('comment', $comment_text)
	->setProperty('actions', $actions)
	->save();

	$draft_engine = $this->newDraftEngine($object);
	if ($draft_engine) {
	$draft_engine
	->setVersionedDraft($draft)
	->synchronize();
	}
	}
	}

	$xactions = array();

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

	if ($actions) {
	$action_map = array();
	foreach ($actions as $action) {
	$type = idx($action, 'type');
	if (!$type) {
	continue;
	}

	if (empty($fields[$type])) {
	continue;
	}

	$action_map[$type] = $action;
	}

	foreach ($action_map as $type => $action) {
	$field = $fields[$type];

	if (!$field->shouldGenerateTransactionsFromComment()) {
	continue;
	}

	// If you don't have edit permission on the object, you're limited in
	// which actions you can take via the comment form. Most actions
	// need edit permission, but some actions (like "Accept Revision")
	// can be applied by anyone with view permission.
	if (!$can_edit) {
	if (!$field->getCanApplyWithoutEditCapability()) {
	// We know the user doesn't have the capability, so this will
	// raise a policy exception.
	PhabricatorPolicyFilter::requireCapability(
	$viewer,
	$object,
	PhabricatorPolicyCapability::CAN_EDIT);
	}
	}

	if (array_key_exists('initialValue', $action)) {
	$field->setInitialValue($action['initialValue']);
	}

	$field->readValueFromComment(idx($action, 'value'));

	$type_xactions = $field->generateTransactions(
	clone $template,
	array(
	'value' => $field->getValueForTransaction(),
	));
	foreach ($type_xactions as $type_xaction) {
	$xactions[] = $type_xaction;
	}
	}
	}

	$auto_xactions = $this->newAutomaticCommentTransactions($object);
	foreach ($auto_xactions as $xaction) {
	$xactions[] = $xaction;
	}

	if (strlen($comment_text) \|\| !$xactions) {
	$xactions[] = id(clone $template)
	->setTransactionType(PhabricatorTransactions::TYPE_COMMENT)
	->attachComment(
	id(clone $comment_template)
	->setContent($comment_text));
	}

	$editor = $object->getApplicationTransactionEditor()
	->setActor($viewer)
	->setContinueOnNoEffect($request->isContinueRequest())
	->setContinueOnMissingFields(true)
	->setContentSourceFromRequest($request)
	->setIsPreview($is_preview);

	try {
	$xactions = $editor->applyTransactions($object, $xactions);
	} catch (PhabricatorApplicationTransactionValidationException $ex) {
	return id(new PhabricatorApplicationTransactionValidationResponse())
	->setCancelURI($view_uri)
	->setException($ex);
	} catch (PhabricatorApplicationTransactionNoEffectException $ex) {
	return id(new PhabricatorApplicationTransactionNoEffectResponse())
	->setCancelURI($view_uri)
	->setException($ex);
	}

	if (!$is_preview) {
	PhabricatorVersionedDraft::purgeDrafts(
	$object->getPHID(),
	$viewer->getPHID(),
	$this->loadDraftVersion($object));

	$draft_engine = $this->newDraftEngine($object);
	if ($draft_engine) {
	$draft_engine
	->setVersionedDraft(null)
	->synchronize();
	}
	}

	if ($request->isAjax() && $is_preview) {
	$preview_content = $this->newCommentPreviewContent($object, $xactions);

	return id(new PhabricatorApplicationTransactionResponse())
	->setViewer($viewer)
	->setTransactions($xactions)
	->setIsPreview($is_preview)
	->setPreviewContent($preview_content);
	} else {
	return id(new AphrontRedirectResponse())
	->setURI($view_uri);
	}
	}

	protected function newDraftEngine($object) {
	$viewer = $this->getViewer();

	if ($object instanceof PhabricatorDraftInterface) {
	$engine = $object->newDraftEngine();
	} else {
	$engine = new PhabricatorBuiltinDraftEngine();
	}

	return $engine
	->setObject($object)
	->setViewer($viewer);
	}


	/* -( Conduit )------------------------------------------------------------ */


	/**
	* Respond to a Conduit edit request.
	*
	* This method accepts a list of transactions to apply to an object, and
	* either edits an existing object or creates a new one.
	*
	* @task conduit
	*/
	final public function buildConduitResponse(ConduitAPIRequest $request) {
	$viewer = $this->getViewer();

	$config = $this->loadDefaultConfiguration();
	if (!$config) {
	throw new Exception(
	pht(
	'Unable to load configuration for this EditEngine ("%s").',
	get_class($this)));
	}

	$raw_xactions = $this->getRawConduitTransactions($request);

	$identifier = $request->getValue('objectIdentifier');
	if ($identifier) {
	$this->setIsCreate(false);
	$object = $this->newObjectFromIdentifier($identifier);
	} else {
	$this->requireCreateCapability();

	$this->setIsCreate(true);
	$object = $this->newEditableObjectFromConduit($raw_xactions);
	}

	$this->validateObject($object);

	$fields = $this->buildEditFields($object);

	$types = $this->getConduitEditTypesFromFields($fields);
	$template = $object->getApplicationTransactionTemplate();

	$xactions = $this->getConduitTransactions(
	$request,
	$raw_xactions,
	$types,
	$template);

	$editor = $object->getApplicationTransactionEditor()
	->setActor($viewer)
	->setContentSource($request->newContentSource())
	->setContinueOnNoEffect(true);

	if (!$this->getIsCreate()) {
	$editor->setContinueOnMissingFields(true);
	}

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

	$xactions_struct = array();
	foreach ($xactions as $xaction) {
	$xactions_struct[] = array(
	'phid' => $xaction->getPHID(),
	);
	}

	return array(
	'object' => array(
	'id' => $object->getID(),
	'phid' => $object->getPHID(),
	),
	'transactions' => $xactions_struct,
	);
	}

	private function getRawConduitTransactions(ConduitAPIRequest $request) {
	$transactions_key = 'transactions';

	$xactions = $request->getValue($transactions_key);
	if (!is_array($xactions)) {
	throw new Exception(
	pht(
	'Parameter "%s" is not a list of transactions.',
	$transactions_key));
	}

	foreach ($xactions as $key => $xaction) {
	if (!is_array($xaction)) {
	throw new Exception(
	pht(
	'Parameter "%s" must contain a list of transaction descriptions, '.
	'but item with key "%s" is not a dictionary.',
	$transactions_key,
	$key));
	}

	if (!array_key_exists('type', $xaction)) {
	throw new Exception(
	pht(
	'Parameter "%s" must contain a list of transaction descriptions, '.
	'but item with key "%s" is missing a "type" field. Each '.
	'transaction must have a type field.',
	$transactions_key,
	$key));
	}
	}

	return $xactions;
	}


	/**
	* Generate transactions which can be applied from edit actions in a Conduit
	* request.
	*
	* @param ConduitAPIRequest The request.
	* @param list<wild> Raw conduit transactions.
	* @param list<PhabricatorEditType> Supported edit types.
	* @param PhabricatorApplicationTransaction Template transaction.
	* @return list<PhabricatorApplicationTransaction> Generated transactions.
	* @task conduit
	*/
	private function getConduitTransactions(
	ConduitAPIRequest $request,
	array $xactions,
	array $types,
	PhabricatorApplicationTransaction $template) {

	$viewer = $request->getUser();
	$results = array();

	foreach ($xactions as $key => $xaction) {
	$type = $xaction['type'];
	if (empty($types[$type])) {
	throw new Exception(
	pht(
	'Transaction with key "%s" has invalid type "%s". This type is '.
	'not recognized. Valid types are: %s.',
	$key,
	$type,
	implode(', ', array_keys($types))));
	}
	}

	if ($this->getIsCreate()) {
	$results[] = id(clone $template)
	->setTransactionType(PhabricatorTransactions::TYPE_CREATE);
	}

	foreach ($xactions as $xaction) {
	$type = $types[$xaction['type']];

	// Let the parameter type interpret the value. This allows you to
	// use usernames in list<user> fields, for example.
	$parameter_type = $type->getConduitParameterType();

	$parameter_type->setViewer($viewer);

	try {
	$xaction['value'] = $parameter_type->getValue(
	$xaction,
	'value',
	$request->getIsStrictlyTyped());
	} catch (Exception $ex) {
	throw new PhutilProxyException(
	pht(
	'Exception when processing transaction of type "%s": %s',
	$xaction['type'],
	$ex->getMessage()),
	$ex);
	}

	$type_xactions = $type->generateTransactions(
	clone $template,
	$xaction);

	foreach ($type_xactions as $type_xaction) {
	$results[] = $type_xaction;
	}
	}

	return $results;
	}


	/**
	* @return map<string, PhabricatorEditType>
	* @task conduit
	*/
	private function getConduitEditTypesFromFields(array $fields) {
	$types = array();
	foreach ($fields as $field) {
	$field_types = $field->getConduitEditTypes();

	if ($field_types === null) {
	continue;
	}

	foreach ($field_types as $field_type) {
	- $field_type->setField($field);
	$types[$field_type->getEditType()] = $field_type;
	}
	}
	return $types;
	}

	public function getConduitEditTypes() {
	$config = $this->loadDefaultConfiguration();
	if (!$config) {
	return array();
	}

	$object = $this->newEditableObjectForDocumentation();
	$fields = $this->buildEditFields($object);
	return $this->getConduitEditTypesFromFields($fields);
	}

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

	final public static function getByKey(PhabricatorUser $viewer, $key) {
	return id(new PhabricatorEditEngineQuery())
	->setViewer($viewer)
	->withEngineKeys(array($key))
	->executeOne();
	}

	public function getIcon() {
	$application = $this->getApplication();
	return $application->getIcon();
	}

	private function loadUsableConfigurationsForCreate() {
	$viewer = $this->getViewer();

	$configs = id(new PhabricatorEditEngineConfigurationQuery())
	->setViewer($viewer)
	->withEngineKeys(array($this->getEngineKey()))
	->withIsDefault(true)
	->withIsDisabled(false)
	->execute();

	$configs = msort($configs, 'getCreateSortKey');

	// Attach this specific engine to configurations we load so they can access
	// any runtime configuration. For example, this allows us to generate the
	// correct "Create Form" buttons when editing forms, see T12301.
	foreach ($configs as $config) {
	$config->attachEngine($this);
	}

	return $configs;
	}

	protected function getValidationExceptionShortMessage(
	PhabricatorApplicationTransactionValidationException $ex,
	PhabricatorEditField $field) {

	$xaction_type = $field->getTransactionType();
	if ($xaction_type === null) {
	return null;
	}

	return $ex->getShortMessage($xaction_type);
	}

	protected function getCreateNewObjectPolicy() {
	return PhabricatorPolicies::POLICY_USER;
	}

	private function requireCreateCapability() {
	PhabricatorPolicyFilter::requireCapability(
	$this->getViewer(),
	$this,
	PhabricatorPolicyCapability::CAN_EDIT);
	}

	private function hasCreateCapability() {
	return PhabricatorPolicyFilter::hasCapability(
	$this->getViewer(),
	$this,
	PhabricatorPolicyCapability::CAN_EDIT);
	}

	public function isCommentAction() {
	return ($this->getEditAction() == 'comment');
	}

	public function getEditAction() {
	$controller = $this->getController();
	$request = $controller->getRequest();
	return $request->getURIData('editAction');
	}

	protected function newCommentActionGroups() {
	return array();
	}

	protected function newAutomaticCommentTransactions($object) {
	return array();
	}

	protected function newCommentPreviewContent($object, array $xactions) {
	return null;
	}


	/* -( Form Pages )--------------------------------------------------------- */


	public function getSelectedPage() {
	return $this->page;
	}


	private function selectPage($object, $page_key) {
	$pages = $this->getPages($object);

	if (empty($pages[$page_key])) {
	return null;
	}

	$this->page = $pages[$page_key];
	return $this->page;
	}


	protected function newPages($object) {
	return array();
	}


	protected function getPages($object) {
	if ($this->pages === null) {
	$pages = $this->newPages($object);

	assert_instances_of($pages, 'PhabricatorEditPage');
	$pages = mpull($pages, null, 'getKey');

	$this->pages = $pages;
	}

	return $this->pages;
	}

	private function applyPageToFields($object, array $fields) {
	$pages = $this->getPages($object);
	if (!$pages) {
	return $fields;
	}

	if (!$this->getSelectedPage()) {
	return $fields;
	}

	$page_picks = array();
	$default_key = head($pages)->getKey();
	foreach ($pages as $page_key => $page) {
	foreach ($page->getFieldKeys() as $field_key) {
	$page_picks[$field_key] = $page_key;
	}
	if ($page->getIsDefault()) {
	$default_key = $page_key;
	}
	}

	$page_map = array_fill_keys(array_keys($pages), array());
	foreach ($fields as $field_key => $field) {
	if (isset($page_picks[$field_key])) {
	$page_map[$page_picks[$field_key]][$field_key] = $field;
	continue;
	}

	// TODO: Maybe let the field pick a page to associate itself with so
	// extensions can force themselves onto a particular page?

	$page_map[$default_key][$field_key] = $field;
	}

	$page = $this->getSelectedPage();
	if (!$page) {
	$page = head($pages);
	}

	$selected_key = $page->getKey();
	return $page_map[$selected_key];
	}

	protected function willApplyTransactions($object, array $xactions) {
	return $xactions;
	}

	protected function didApplyTransactions($object, array $xactions) {
	return;
	}


	/* -( Bulk Edits )--------------------------------------------------------- */


	final public function newBulkEditMap() {
	$config = $this->loadDefaultConfiguration();
	if (!$config) {
	throw new Exception(
	pht('No default edit engine configuration for bulk edit.'));
	}

	$object = $this->newEditableObject();
	$fields = $this->buildEditFields($object);

	$edit_types = $this->getBulkEditTypesFromFields($fields);

	$map = array();
	foreach ($edit_types as $key => $type) {
	$bulk_type = $type->getBulkParameterType();
	if ($bulk_type === null) {
	continue;
	}

	$bulk_label = $type->getBulkEditLabel();
	if ($bulk_label === null) {
	continue;
	}

	$map[] = array(
	'label' => $bulk_label,
	'xaction' => $key,
	'control' => array(
	'type' => $bulk_type->getPHUIXControlType(),
	'spec' => (object)$bulk_type->getPHUIXControlSpecification(),
	),
	);
	}

	return $map;
	}


	final public function newRawBulkTransactions(array $xactions) {
	$config = $this->loadDefaultConfiguration();
	if (!$config) {
	throw new Exception(
	pht('No default edit engine configuration for bulk edit.'));
	}

	$object = $this->newEditableObject();
	$fields = $this->buildEditFields($object);

	$edit_types = $this->getBulkEditTypesFromFields($fields);

	foreach ($xactions as $key => $xaction) {
	PhutilTypeSpec::checkMap(
	$xaction,
	array(
	'type' => 'string',
	'value' => 'optional wild',
	'comment' => 'optional string',
	));

	$type = $xaction['type'];
	if (!isset($edit_types[$type])) {
	throw new Exception(
	pht(
	'Unsupported bulk edit type "%s".',
	$type));
	}

	$edit_type = $edit_types[$type];

	// Replace the edit type with the underlying transaction type. Usually
	// these are 1:1 and the transaction type just has more internal noise,
	// but it's possible that this isn't the case.
	$xaction['type'] = $edit_type->getTransactionType();

	$xaction['metadata'] = $edit_type->getMetadata();

	$xaction = $edit_type->newRawBulkTransaction($xaction);
	if ($xaction === null) {
	unset($xactions[$key]);
	continue;
	}

	$xactions[$key] = $xaction;
	}

	return $xactions;
	}

	private function getBulkEditTypesFromFields(array $fields) {
	$types = array();

	foreach ($fields as $field) {
	$field_types = $field->getBulkEditTypes();

	if ($field_types === null) {
	continue;
	}

	foreach ($field_types as $field_type) {
	- $field_type->setField($field);
	$types[$field_type->getEditType()] = $field_type;
	}
	}

	return $types;
	}


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


	public function getPHID() {
	return get_class($this);
	}

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

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

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	return false;
	}

	}
	diff --git a/src/applications/transactions/editfield/PhabricatorEditField.php b/src/applications/transactions/editfield/PhabricatorEditField.php
	index c0d0cdd8c8..ad8b7372a5 100644
	--- a/src/applications/transactions/editfield/PhabricatorEditField.php
	+++ b/src/applications/transactions/editfield/PhabricatorEditField.php
	@@ -1,908 +1,902 @@
	<?php

	abstract class PhabricatorEditField extends Phobject {

	private $key;
	private $viewer;
	private $label;
	private $aliases = array();
	private $value;
	private $initialValue;
	private $hasValue = false;
	private $object;
	private $transactionType;
	private $metadata = array();
	private $editTypeKey;
	private $isRequired;
	private $previewPanel;
	private $controlID;
	private $controlInstructions;
	private $bulkEditLabel;

	private $description;
	private $conduitDescription;
	private $conduitDocumentation;
	private $conduitTypeDescription;

	private $commentActionLabel;
	private $commentActionValue;
	private $commentActionGroupKey;
	private $commentActionOrder = 1000;
	private $hasCommentActionValue;

	private $isLocked;
	private $isHidden;

	private $isPreview;
	private $isEditDefaults;
	private $isSubmittedForm;
	private $controlError;
	private $canApplyWithoutEditCapability = false;

	private $isReorderable = true;
	private $isDefaultable = true;
	private $isLockable = true;
	private $isCopyable = false;
	private $isConduitOnly = false;

	private $conduitEditTypes;
	private $bulkEditTypes;

	public function setKey($key) {
	$this->key = $key;
	return $this;
	}

	public function getKey() {
	return $this->key;
	}

	public function setLabel($label) {
	$this->label = $label;
	return $this;
	}

	public function getLabel() {
	return $this->label;
	}

	public function setBulkEditLabel($bulk_edit_label) {
	$this->bulkEditLabel = $bulk_edit_label;
	return $this;
	}

	public function getBulkEditLabel() {
	return $this->bulkEditLabel;
	}

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

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

	public function setAliases(array $aliases) {
	$this->aliases = $aliases;
	return $this;
	}

	public function getAliases() {
	return $this->aliases;
	}

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

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

	public function setIsLocked($is_locked) {
	$this->isLocked = $is_locked;
	return $this;
	}

	public function getIsLocked() {
	return $this->isLocked;
	}

	public function setIsPreview($preview) {
	$this->isPreview = $preview;
	return $this;
	}

	public function getIsPreview() {
	return $this->isPreview;
	}

	public function setIsReorderable($is_reorderable) {
	$this->isReorderable = $is_reorderable;
	return $this;
	}

	public function getIsReorderable() {
	return $this->isReorderable;
	}

	public function setIsConduitOnly($is_conduit_only) {
	$this->isConduitOnly = $is_conduit_only;
	return $this;
	}

	public function getIsConduitOnly() {
	return $this->isConduitOnly;
	}

	public function setDescription($description) {
	$this->description = $description;
	return $this;
	}

	public function getDescription() {
	return $this->description;
	}

	public function setConduitDescription($conduit_description) {
	$this->conduitDescription = $conduit_description;
	return $this;
	}

	public function getConduitDescription() {
	if ($this->conduitDescription === null) {
	return $this->getDescription();
	}
	return $this->conduitDescription;
	}

	public function setConduitDocumentation($conduit_documentation) {
	$this->conduitDocumentation = $conduit_documentation;
	return $this;
	}

	public function getConduitDocumentation() {
	return $this->conduitDocumentation;
	}

	public function setConduitTypeDescription($conduit_type_description) {
	$this->conduitTypeDescription = $conduit_type_description;
	return $this;
	}

	public function getConduitTypeDescription() {
	return $this->conduitTypeDescription;
	}

	public function setIsEditDefaults($is_edit_defaults) {
	$this->isEditDefaults = $is_edit_defaults;
	return $this;
	}

	public function getIsEditDefaults() {
	return $this->isEditDefaults;
	}

	public function setIsDefaultable($is_defaultable) {
	$this->isDefaultable = $is_defaultable;
	return $this;
	}

	public function getIsDefaultable() {
	return $this->isDefaultable;
	}

	public function setIsLockable($is_lockable) {
	$this->isLockable = $is_lockable;
	return $this;
	}

	public function getIsLockable() {
	return $this->isLockable;
	}

	public function setIsHidden($is_hidden) {
	$this->isHidden = $is_hidden;
	return $this;
	}

	public function getIsHidden() {
	return $this->isHidden;
	}

	public function setIsCopyable($is_copyable) {
	$this->isCopyable = $is_copyable;
	return $this;
	}

	public function getIsCopyable() {
	return $this->isCopyable;
	}

	public function setIsSubmittedForm($is_submitted) {
	$this->isSubmittedForm = $is_submitted;
	return $this;
	}

	public function getIsSubmittedForm() {
	return $this->isSubmittedForm;
	}

	public function setIsRequired($is_required) {
	$this->isRequired = $is_required;
	return $this;
	}

	public function getIsRequired() {
	return $this->isRequired;
	}

	public function setControlError($control_error) {
	$this->controlError = $control_error;
	return $this;
	}

	public function getControlError() {
	return $this->controlError;
	}

	public function setCommentActionLabel($label) {
	$this->commentActionLabel = $label;
	return $this;
	}

	public function getCommentActionLabel() {
	return $this->commentActionLabel;
	}

	public function setCommentActionGroupKey($key) {
	$this->commentActionGroupKey = $key;
	return $this;
	}

	public function getCommentActionGroupKey() {
	return $this->commentActionGroupKey;
	}

	public function setCommentActionOrder($order) {
	$this->commentActionOrder = $order;
	return $this;
	}

	public function getCommentActionOrder() {
	return $this->commentActionOrder;
	}

	public function setCommentActionValue($comment_action_value) {
	$this->hasCommentActionValue = true;
	$this->commentActionValue = $comment_action_value;
	return $this;
	}

	public function getCommentActionValue() {
	return $this->commentActionValue;
	}

	public function setPreviewPanel(PHUIRemarkupPreviewPanel $preview_panel) {
	$this->previewPanel = $preview_panel;
	return $this;
	}

	public function getPreviewPanel() {
	return $this->previewPanel;
	}

	public function setControlInstructions($control_instructions) {
	$this->controlInstructions = $control_instructions;
	return $this;
	}

	public function getControlInstructions() {
	return $this->controlInstructions;
	}

	public function setCanApplyWithoutEditCapability($can_apply) {
	$this->canApplyWithoutEditCapability = $can_apply;
	return $this;
	}

	public function getCanApplyWithoutEditCapability() {
	return $this->canApplyWithoutEditCapability;
	}

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

	protected function buildControl() {
	if ($this->getIsConduitOnly()) {
	return null;
	}

	$control = $this->newControl();
	if ($control === null) {
	return null;
	}

	$control
	->setValue($this->getValueForControl())
	->setName($this->getKey());

	if (!$control->getLabel()) {
	$control->setLabel($this->getLabel());
	}

	if ($this->getIsSubmittedForm()) {
	$error = $this->getControlError();
	if ($error !== null) {
	$control->setError($error);
	}
	} else if ($this->getIsRequired()) {
	$control->setError(true);
	}

	return $control;
	}

	public function getControlID() {
	if (!$this->controlID) {
	$this->controlID = celerity_generate_unique_node_id();
	}
	return $this->controlID;
	}

	protected function renderControl() {
	$control = $this->buildControl();
	if ($control === null) {
	return null;
	}

	if ($this->getIsPreview()) {
	$disabled = true;
	$hidden = false;
	} else if ($this->getIsEditDefaults()) {
	$disabled = false;
	$hidden = false;
	} else {
	$disabled = $this->getIsLocked();
	$hidden = $this->getIsHidden();
	}

	if ($hidden) {
	return null;
	}

	$control->setDisabled($disabled);

	if ($this->controlID) {
	$control->setID($this->controlID);
	}

	return $control;
	}

	public function appendToForm(AphrontFormView $form) {
	$control = $this->renderControl();
	if ($control !== null) {

	if ($this->getIsPreview()) {
	if ($this->getIsHidden()) {
	$control
	->addClass('aphront-form-preview-hidden')
	->setError(pht('Hidden'));
	} else if ($this->getIsLocked()) {
	$control
	->setError(pht('Locked'));
	}
	}

	$instructions = $this->getControlInstructions();
	if (strlen($instructions)) {
	$form->appendRemarkupInstructions($instructions);
	}

	$form->appendControl($control);
	}
	return $this;
	}

	protected function getValueForControl() {
	return $this->getValue();
	}

	public function getValueForDefaults() {
	$value = $this->getValue();

	// By default, just treat the empty string like `null` since they're
	// equivalent for almost all fields and this reduces the number of
	// meaningless transactions we generate when adjusting defaults.
	if ($value === '') {
	return null;
	}

	return $value;
	}

	protected function getValue() {
	return $this->value;
	}

	public function setValue($value) {
	$this->hasValue = true;
	$this->value = $value;

	// If we don't have an initial value set yet, use the value as the
	// initial value.
	$initial_value = $this->getInitialValue();
	if ($initial_value === null) {
	$this->initialValue = $value;
	}

	return $this;
	}

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

	public function getMetadata() {
	return $this->metadata;
	}

	public function getValueForTransaction() {
	return $this->getValue();
	}

	public function getTransactionType() {
	return $this->transactionType;
	}

	public function setTransactionType($type) {
	$this->transactionType = $type;
	return $this;
	}

	public function readValueFromRequest(AphrontRequest $request) {
	$check = $this->getAllReadValueFromRequestKeys();
	foreach ($check as $key) {
	if (!$this->getValueExistsInRequest($request, $key)) {
	continue;
	}

	$this->value = $this->getValueFromRequest($request, $key);
	break;
	}
	return $this;
	}

	public function readValueFromComment($value) {
	$this->value = $this->getValueFromComment($value);
	return $this;
	}

	protected function getValueFromComment($value) {
	return $value;
	}

	public function getAllReadValueFromRequestKeys() {
	$keys = array();

	$keys[] = $this->getKey();
	foreach ($this->getAliases() as $alias) {
	$keys[] = $alias;
	}

	return $keys;
	}

	public function readDefaultValueFromConfiguration($value) {
	$this->value = $this->getDefaultValueFromConfiguration($value);
	return $this;
	}

	protected function getDefaultValueFromConfiguration($value) {
	return $value;
	}

	protected function getValueFromObject($object) {
	if ($this->hasValue) {
	return $this->value;
	} else {
	return $this->getDefaultValue();
	}
	}

	protected function getValueExistsInRequest(AphrontRequest $request, $key) {
	return $this->getHTTPParameterValueExists($request, $key);
	}

	protected function getValueFromRequest(AphrontRequest $request, $key) {
	return $this->getHTTPParameterValue($request, $key);
	}

	public function readValueFromField(PhabricatorEditField $other) {
	$this->value = $this->getValueFromField($other);
	return $this;
	}

	protected function getValueFromField(PhabricatorEditField $other) {
	return $other->getValue();
	}


	/**
	* Read and return the value the object had when the user first loaded the
	* form.
	*
	* This is the initial value from the user's point of view when they started
	* the edit process, and used primarily to prevent race conditions for fields
	* like "Projects" and "Subscribers" that use tokenizers and support edge
	* transactions.
	*
	* Most fields do not need to store these values or deal with initial value
	* handling.
	*
	* @param AphrontRequest Request to read from.
	* @param string Key to read.
	* @return wild Value read from request.
	*/
	protected function getInitialValueFromSubmit(AphrontRequest $request, $key) {
	return null;
	}

	public function getInitialValue() {
	return $this->initialValue;
	}

	public function setInitialValue($initial_value) {
	$this->initialValue = $initial_value;
	return $this;
	}

	public function readValueFromSubmit(AphrontRequest $request) {
	$key = $this->getKey();
	if ($this->getValueExistsInSubmit($request, $key)) {
	$value = $this->getValueFromSubmit($request, $key);
	} else {
	$value = $this->getDefaultValue();
	}
	$this->value = $value;

	$initial_value = $this->getInitialValueFromSubmit($request, $key);
	$this->initialValue = $initial_value;

	return $this;
	}

	protected function getValueExistsInSubmit(AphrontRequest $request, $key) {
	return $this->getHTTPParameterValueExists($request, $key);
	}

	protected function getValueFromSubmit(AphrontRequest $request, $key) {
	return $this->getHTTPParameterValue($request, $key);
	}

	protected function getHTTPParameterValueExists(
	AphrontRequest $request,
	$key) {
	$type = $this->getHTTPParameterType();

	if ($type) {
	return $type->getExists($request, $key);
	}

	return false;
	}

	protected function getHTTPParameterValue($request, $key) {
	$type = $this->getHTTPParameterType();

	if ($type) {
	return $type->getValue($request, $key);
	}

	return null;
	}

	protected function getDefaultValue() {
	$type = $this->getHTTPParameterType();

	if ($type) {
	return $type->getDefaultValue();
	}

	return null;
	}

	final public function getHTTPParameterType() {
	if ($this->getIsConduitOnly()) {
	return null;
	}

	$type = $this->newHTTPParameterType();

	if ($type) {
	$type->setViewer($this->getViewer());
	}

	return $type;
	}

	protected function newHTTPParameterType() {
	return new AphrontStringHTTPParameterType();
	}

	protected function getBulkParameterType() {
	$type = $this->newBulkParameterType();

	if (!$type) {
	return null;
	}

	$type
	->setField($this)
	->setViewer($this->getViewer());

	return $type;
	}

	protected function newBulkParameterType() {
	return null;
	}

	public function getConduitParameterType() {
	$type = $this->newConduitParameterType();

	if (!$type) {
	return null;
	}

	$type->setViewer($this->getViewer());

	return $type;
	}

	abstract protected function newConduitParameterType();

	public function setEditTypeKey($edit_type_key) {
	$this->editTypeKey = $edit_type_key;
	return $this;
	}

	public function getEditTypeKey() {
	if ($this->editTypeKey === null) {
	return $this->getKey();
	}
	return $this->editTypeKey;
	}

	protected function newEditType() {
	- $parameter_type = $this->getConduitParameterType();
	- if (!$parameter_type) {
	- return null;
	- }
	-
	- $edit_type = id(new PhabricatorSimpleEditType())
	- ->setConduitParameterType($parameter_type);
	-
	- $bulk_type = $this->getBulkParameterType();
	- if ($bulk_type) {
	- $edit_type->setBulkParameterType($bulk_type);
	- }
	-
	- return $edit_type;
	+ return new PhabricatorSimpleEditType();
	}

	protected function getEditType() {
	$transaction_type = $this->getTransactionType();
	-
	if ($transaction_type === null) {
	return null;
	}

	- $type_key = $this->getEditTypeKey();
	$edit_type = $this->newEditType();
	if (!$edit_type) {
	return null;
	}

	- return $edit_type
	- ->setEditType($type_key)
	+ $type_key = $this->getEditTypeKey();
	+
	+ $edit_type
	+ ->setEditField($this)
	->setTransactionType($transaction_type)
	+ ->setEditType($type_key)
	->setMetadata($this->getMetadata());
	+
	+ if (!$edit_type->getConduitParameterType()) {
	+ $conduit_parameter = $this->getConduitParameterType();
	+ if ($conduit_parameter) {
	+ $edit_type->setConduitParameterType($conduit_parameter);
	+ }
	+ }
	+
	+ if (!$edit_type->getBulkParameterType()) {
	+ $bulk_parameter = $this->getBulkParameterType();
	+ if ($bulk_parameter) {
	+ $edit_type->setBulkParameterType($bulk_parameter);
	+ }
	+ }
	+
	+ return $edit_type;
	}

	final public function getConduitEditTypes() {
	if ($this->conduitEditTypes === null) {
	$edit_types = $this->newConduitEditTypes();
	$edit_types = mpull($edit_types, null, 'getEditType');
	-
	- foreach ($edit_types as $edit_type) {
	- $edit_type->setEditField($this);
	- }
	-
	$this->conduitEditTypes = $edit_types;
	}

	return $this->conduitEditTypes;
	}

	final public function getConduitEditType($key) {
	$edit_types = $this->getConduitEditTypes();

	if (empty($edit_types[$key])) {
	throw new Exception(
	pht(
	'This EditField does not provide a Conduit EditType with key "%s".',
	$key));
	}

	return $edit_types[$key];
	}

	protected function newConduitEditTypes() {
	$edit_type = $this->getEditType();

	if (!$edit_type) {
	return array();
	}

	return array($edit_type);
	}

	final public function getBulkEditTypes() {
	if ($this->bulkEditTypes === null) {
	$edit_types = $this->newBulkEditTypes();
	$edit_types = mpull($edit_types, null, 'getEditType');
	-
	- foreach ($edit_types as $edit_type) {
	- $edit_type->setEditField($this);
	- }
	-
	$this->bulkEditTypes = $edit_types;
	}

	return $this->bulkEditTypes;
	}

	final public function getBulkEditType($key) {
	$edit_types = $this->getBulkEditTypes();

	if (empty($edit_types[$key])) {
	throw new Exception(
	pht(
	'This EditField does not provide a Bulk EditType with key "%s".',
	$key));
	}

	return $edit_types[$key];
	}

	protected function newBulkEditTypes() {
	$edit_type = $this->getEditType();

	if (!$edit_type) {
	return array();
	}

	return array($edit_type);
	}

	public function getCommentAction() {
	$label = $this->getCommentActionLabel();
	if ($label === null) {
	return null;
	}

	$action = $this->newCommentAction();
	if ($action === null) {
	return null;
	}

	if ($this->hasCommentActionValue) {
	$value = $this->getCommentActionValue();
	} else {
	$value = $this->getValue();
	}

	$action
	->setKey($this->getKey())
	->setLabel($label)
	->setValue($this->getValueForCommentAction($value))
	->setOrder($this->getCommentActionOrder())
	->setGroupKey($this->getCommentActionGroupKey());

	return $action;
	}

	protected function newCommentAction() {
	return null;
	}

	protected function getValueForCommentAction($value) {
	return $value;
	}

	public function shouldGenerateTransactionsFromSubmit() {
	if ($this->getIsConduitOnly()) {
	return false;
	}

	$edit_type = $this->getEditType();
	if (!$edit_type) {
	return false;
	}

	return true;
	}

	public function shouldReadValueFromRequest() {
	if ($this->getIsConduitOnly()) {
	return false;
	}

	if ($this->getIsLocked()) {
	return false;
	}

	if ($this->getIsHidden()) {
	return false;
	}

	return true;
	}

	public function shouldReadValueFromSubmit() {
	if ($this->getIsConduitOnly()) {
	return false;
	}

	if ($this->getIsLocked()) {
	return false;
	}

	if ($this->getIsHidden()) {
	return false;
	}

	return true;
	}

	public function shouldGenerateTransactionsFromComment() {
	if ($this->getIsConduitOnly()) {
	return false;
	}

	if ($this->getIsLocked()) {
	return false;
	}

	if ($this->getIsHidden()) {
	return false;
	}

	return true;
	}

	public function generateTransactions(
	PhabricatorApplicationTransaction $template,
	array $spec) {

	$edit_type = $this->getEditType();
	if (!$edit_type) {
	throw new Exception(
	pht(
	'EditField (with key "%s", of class "%s") is generating '.
	'transactions, but has no EditType.',
	$this->getKey(),
	get_class($this)));
	}

	return $edit_type->generateTransactions($template, $spec);
	}

	}
	diff --git a/src/applications/transactions/editfield/PhabricatorPHIDListEditField.php b/src/applications/transactions/editfield/PhabricatorPHIDListEditField.php
	index e29206c8ba..b084c142e5 100644
	--- a/src/applications/transactions/editfield/PhabricatorPHIDListEditField.php
	+++ b/src/applications/transactions/editfield/PhabricatorPHIDListEditField.php
	@@ -1,150 +1,148 @@
	<?php

	abstract class PhabricatorPHIDListEditField
	extends PhabricatorEditField {

	private $useEdgeTransactions;
	private $isSingleValue;

	public function setUseEdgeTransactions($use_edge_transactions) {
	$this->useEdgeTransactions = $use_edge_transactions;
	return $this;
	}

	public function getUseEdgeTransactions() {
	return $this->useEdgeTransactions;
	}

	public function setSingleValue($value) {
	if ($value === null) {
	$value = array();
	} else {
	$value = array($value);
	}

	$this->isSingleValue = true;
	return $this->setValue($value);
	}

	public function getIsSingleValue() {
	return $this->isSingleValue;
	}

	protected function newHTTPParameterType() {
	return new AphrontPHIDListHTTPParameterType();
	}

	protected function newConduitParameterType() {
	if ($this->getIsSingleValue()) {
	return new ConduitPHIDParameterType();
	} else {
	return new ConduitPHIDListParameterType();
	}
	}

	protected function getValueFromRequest(AphrontRequest $request, $key) {
	$value = parent::getValueFromRequest($request, $key);
	if ($this->getIsSingleValue()) {
	$value = array_slice($value, 0, 1);
	}
	return $value;
	}

	public function getValueForTransaction() {
	$new = parent::getValueForTransaction();

	if ($this->getIsSingleValue()) {
	if ($new) {
	return head($new);
	} else {
	return null;
	}
	}

	if (!$this->getUseEdgeTransactions()) {
	return $new;
	}

	$old = $this->getInitialValue();
	if ($old === null) {
	return array(
	'=' => array_fuse($new),
	);
	}

	// If we're building an edge transaction and the request has data about the
	// original value the user saw when they loaded the form, interpret the
	// edit as a mixture of "+" and "-" operations instead of a single "="
	// operation. This limits our exposure to race conditions by making most
	// concurrent edits merge correctly.

	$add = array_diff($new, $old);
	$rem = array_diff($old, $new);

	$value = array();

	if ($add) {
	$value['+'] = array_fuse($add);
	}
	if ($rem) {
	$value['-'] = array_fuse($rem);
	}

	return $value;
	}

	protected function newEditType() {
	if ($this->getUseEdgeTransactions()) {
	return new PhabricatorEdgeEditType();
	}

	- $type = new PhabricatorDatasourceEditType();
	- $type->setIsSingleValue($this->getIsSingleValue());
	- $type->setConduitParameterType($this->newConduitParameterType());
	- return $type;
	+ return id(new PhabricatorDatasourceEditType())
	+ ->setIsSingleValue($this->getIsSingleValue());
	}

	protected function newBulkEditTypes() {
	return $this->newConduitEditTypes();
	}

	protected function newConduitEditTypes() {
	if (!$this->getUseEdgeTransactions()) {
	return parent::newConduitEditTypes();
	}

	$transaction_type = $this->getTransactionType();
	if ($transaction_type === null) {
	return array();
	}

	$type_key = $this->getEditTypeKey();

	$base = $this->getEditType();

	$add = id(clone $base)
	->setEditType($type_key.'.add')
	->setEdgeOperation('+')
	->setConduitTypeDescription(pht('List of PHIDs to add.'))
	->setConduitParameterType($this->getConduitParameterType());

	$rem = id(clone $base)
	->setEditType($type_key.'.remove')
	->setEdgeOperation('-')
	->setConduitTypeDescription(pht('List of PHIDs to remove.'))
	->setConduitParameterType($this->getConduitParameterType());

	$set = id(clone $base)
	->setEditType($type_key.'.set')
	->setEdgeOperation('=')
	->setConduitTypeDescription(pht('List of PHIDs to set.'))
	->setConduitParameterType($this->getConduitParameterType());

	return array(
	$add,
	$rem,
	$set,
	);
	}

	}
	diff --git a/src/applications/transactions/editfield/PhabricatorTokenizerEditField.php b/src/applications/transactions/editfield/PhabricatorTokenizerEditField.php
	index 237f315b51..d657213456 100644
	--- a/src/applications/transactions/editfield/PhabricatorTokenizerEditField.php
	+++ b/src/applications/transactions/editfield/PhabricatorTokenizerEditField.php
	@@ -1,59 +1,67 @@
	<?php

	abstract class PhabricatorTokenizerEditField
	extends PhabricatorPHIDListEditField {

	abstract protected function newDatasource();

	protected function newControl() {
	$control = id(new AphrontFormTokenizerControl())
	->setDatasource($this->newDatasource());

	$initial_value = $this->getInitialValue();
	if ($initial_value !== null) {
	$control->setInitialValue($initial_value);
	}

	if ($this->getIsSingleValue()) {
	$control->setLimit(1);
	}

	return $control;
	}

	protected function getInitialValueFromSubmit(AphrontRequest $request, $key) {
	return $request->getArr($key.'.initial');
	}

	protected function newEditType() {
	$type = parent::newEditType();

	$datasource = $this->newDatasource()
	->setViewer($this->getViewer());
	$type->setDatasource($datasource);

	return $type;
	}

	protected function newCommentAction() {
	$viewer = $this->getViewer();

	$datasource = $this->newDatasource()
	->setViewer($viewer);

	$action = id(new PhabricatorEditEngineTokenizerCommentAction())
	->setDatasource($datasource);

	if ($this->getIsSingleValue()) {
	$action->setLimit(1);
	}

	$initial_value = $this->getInitialValue();
	if ($initial_value !== null) {
	$action->setInitialValue($initial_value);
	}

	return $action;
	}

	+ protected function newBulkParameterType() {
	+ $datasource = $this->newDatasource()
	+ ->setViewer($this->getViewer());
	+
	+ return id(new BulkTokenizerParameterType())
	+ ->setDatasource($datasource);
	+ }
	+
	}
	diff --git a/src/applications/transactions/edittype/PhabricatorDatasourceEditType.php b/src/applications/transactions/edittype/PhabricatorDatasourceEditType.php
	index b6e1a5d7bb..dcb4f6f023 100644
	--- a/src/applications/transactions/edittype/PhabricatorDatasourceEditType.php
	+++ b/src/applications/transactions/edittype/PhabricatorDatasourceEditType.php
	@@ -1,22 +1,38 @@
	<?php

	final class PhabricatorDatasourceEditType
	extends PhabricatorPHIDListEditType {

	public function generateTransactions(
	PhabricatorApplicationTransaction $template,
	array $spec) {

	$value = idx($spec, 'value');

	$xaction = $this->newTransaction($template)
	->setNewValue($value);

	return array($xaction);
	}

	public function getValueDescription() {
	return '?';
	}

	+ public function newRawBulkTransaction(array $xaction) {
	+ $value = idx($xaction, 'value');
	+
	+ if ($this->getIsSingleValue()) {
	+ if ($value) {
	+ $value = head($value);
	+ } else {
	+ $value = null;
	+ }
	+
	+ $xaction['value'] = $value;
	+ }
	+
	+ return $xaction;
	+ }
	+
	}
	diff --git a/src/applications/transactions/edittype/PhabricatorEdgeEditType.php b/src/applications/transactions/edittype/PhabricatorEdgeEditType.php
	index c5a6777d48..976ab3ec8e 100644
	--- a/src/applications/transactions/edittype/PhabricatorEdgeEditType.php
	+++ b/src/applications/transactions/edittype/PhabricatorEdgeEditType.php
	@@ -1,61 +1,60 @@
	<?php

	final class PhabricatorEdgeEditType
	extends PhabricatorPHIDListEditType {

	private $edgeOperation;
	private $valueDescription;

	public function setEdgeOperation($edge_operation) {
	$this->edgeOperation = $edge_operation;
	return $this;
	}

	public function getEdgeOperation() {
	return $this->edgeOperation;
	}

	public function generateTransactions(
	PhabricatorApplicationTransaction $template,
	array $spec) {

	$value = idx($spec, 'value');

	if ($this->getEdgeOperation() !== null) {
	$value = array_fuse($value);
	$value = array(
	$this->getEdgeOperation() => $value,
	);
	}

	$xaction = $this->newTransaction($template)
	->setNewValue($value);

	return array($xaction);
	}

	protected function newBulkParameterType() {
	if (!$this->getDatasource()) {
	return null;
	}

	return id(new BulkTokenizerParameterType())
	->setDatasource($this->getDatasource());
	}

	-
	public function newRawBulkTransaction(array $xaction) {
	$value = idx($xaction, 'value');

	if ($this->getEdgeOperation() !== null) {
	$value = array_fuse($value);
	$value = array(
	$this->getEdgeOperation() => $value,
	);
	$xaction['value'] = $value;
	}

	return $xaction;
	}

	}
	diff --git a/src/applications/transactions/edittype/PhabricatorEditType.php b/src/applications/transactions/edittype/PhabricatorEditType.php
	index 5c9a9dac92..127fe93e3a 100644
	--- a/src/applications/transactions/edittype/PhabricatorEditType.php
	+++ b/src/applications/transactions/edittype/PhabricatorEditType.php
	@@ -1,210 +1,200 @@
	<?php

	abstract class PhabricatorEditType extends Phobject {

	private $editType;
	private $editField;
	private $transactionType;
	private $label;
	- private $field;
	private $metadata = array();

	private $conduitDescription;
	private $conduitDocumentation;
	private $conduitTypeDescription;
	private $conduitParameterType;

	private $bulkParameterType;
	private $bulkEditLabel;

	public function setLabel($label) {
	$this->label = $label;
	return $this;
	}

	public function getLabel() {
	return $this->label;
	}

	public function setBulkEditLabel($bulk_edit_label) {
	$this->bulkEditLabel = $bulk_edit_label;
	return $this;
	}

	public function getBulkEditLabel() {
	if ($this->bulkEditLabel !== null) {
	return $this->bulkEditLabel;
	}

	- return $this->getField()->getBulkEditLabel();
	- }
	-
	- public function setField(PhabricatorEditField $field) {
	- $this->field = $field;
	- return $this;
	- }
	-
	- public function getField() {
	- return $this->field;
	+ return $this->getEditField()->getBulkEditLabel();
	}

	public function setEditType($edit_type) {
	$this->editType = $edit_type;
	return $this;
	}

	public function getEditType() {
	return $this->editType;
	}

	public function setMetadata($metadata) {
	$this->metadata = $metadata;
	return $this;
	}

	public function getMetadata() {
	return $this->metadata;
	}

	public function setTransactionType($transaction_type) {
	$this->transactionType = $transaction_type;
	return $this;
	}

	public function getTransactionType() {
	return $this->transactionType;
	}

	abstract public function generateTransactions(
	PhabricatorApplicationTransaction $template,
	array $spec);

	protected function newTransaction(
	PhabricatorApplicationTransaction $template) {

	$xaction = id(clone $template)
	->setTransactionType($this->getTransactionType());

	foreach ($this->getMetadata() as $key => $value) {
	$xaction->setMetadataValue($key, $value);
	}

	return $xaction;
	}

	public function setEditField(PhabricatorEditField $edit_field) {
	$this->editField = $edit_field;
	return $this;
	}

	public function getEditField() {
	return $this->editField;
	}


	/* -( Bulk )--------------------------------------------------------------- */


	protected function newBulkParameterType() {
	if ($this->bulkParameterType) {
	return clone $this->bulkParameterType;
	}

	return null;
	}


	public function setBulkParameterType(BulkParameterType $type) {
	$this->bulkParameterType = $type;
	return $this;
	}


	public function getBulkParameterType() {
	return $this->newBulkParameterType();
	}


	public function newRawBulkTransaction(array $xaction) {
	return $xaction;
	}


	/* -( Conduit )------------------------------------------------------------ */


	protected function newConduitParameterType() {
	if ($this->conduitParameterType) {
	return clone $this->conduitParameterType;
	}

	return null;
	}

	public function setConduitParameterType(ConduitParameterType $type) {
	$this->conduitParameterType = $type;
	return $this;
	}

	public function getConduitParameterType() {
	return $this->newConduitParameterType();
	}

	public function getConduitType() {
	$parameter_type = $this->getConduitParameterType();
	if (!$parameter_type) {
	throw new Exception(
	pht(
	'Edit type (with key "%s") is missing a Conduit parameter type.',
	$this->getEditType()));
	}

	return $parameter_type->getTypeName();
	}

	public function setConduitTypeDescription($conduit_type_description) {
	$this->conduitTypeDescription = $conduit_type_description;
	return $this;
	}

	public function getConduitTypeDescription() {
	if ($this->conduitTypeDescription === null) {
	if ($this->getEditField()) {
	return $this->getEditField()->getConduitTypeDescription();
	}
	}

	return $this->conduitTypeDescription;
	}

	public function setConduitDescription($conduit_description) {
	$this->conduitDescription = $conduit_description;
	return $this;
	}

	public function getConduitDescription() {
	if ($this->conduitDescription === null) {
	if ($this->getEditField()) {
	return $this->getEditField()->getConduitDescription();
	}
	}

	return $this->conduitDescription;
	}

	public function setConduitDocumentation($conduit_documentation) {
	$this->conduitDocumentation = $conduit_documentation;
	return $this;
	}

	public function getConduitDocumentation() {
	if ($this->conduitDocumentation === null) {
	if ($this->getEditField()) {
	return $this->getEditField()->getConduitDocumentation();
	}
	}

	return $this->conduitDocumentation;
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Apr 28, 11:02 PM (19 h, 14 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 108126
Default Alt Text: (122 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions