No OneTemporary
Actions

Size

309 KB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/src/applications/almanac/editor/AlmanacBindingEditEngine.php b/src/applications/almanac/editor/AlmanacBindingEditEngine.php
	index 5146578fff..66db7fcbab 100644
	--- a/src/applications/almanac/editor/AlmanacBindingEditEngine.php
	+++ b/src/applications/almanac/editor/AlmanacBindingEditEngine.php
	@@ -1,172 +1,172 @@
	<?php

	final class AlmanacBindingEditEngine
	extends PhabricatorEditEngine {

	const ENGINECONST = 'almanac.binding';

	private $service;

	public function setService(AlmanacService $service) {
	$this->service = $service;
	return $this;
	}

	public function getService() {
	if (!$this->service) {
	throw new PhutilInvalidStateException('setService');
	}
	return $this->service;
	}

	public function isEngineConfigurable() {
	return false;
	}

	public function getEngineName() {
	return pht('Almanac Bindings');
	}

	public function getSummaryHeader() {
	return pht('Edit Almanac Binding Configurations');
	}

	public function getSummaryText() {
	return pht('This engine is used to edit Almanac bindings.');
	}

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

	protected function newEditableObject() {
	$service = $this->getService();
	return AlmanacBinding::initializeNewBinding($service);
	}

	protected function newEditableObjectForDocumentation() {
	$service_type = AlmanacCustomServiceType::SERVICETYPE;
	$service = AlmanacService::initializeNewService($service_type);
	$this->setService($service);
	return $this->newEditableObject();
	}

	protected function newEditableObjectFromConduit(array $raw_xactions) {
	$service_phid = null;
	foreach ($raw_xactions as $raw_xaction) {
	if ($raw_xaction['type'] !== 'service') {
	continue;
	}

	$service_phid = $raw_xaction['value'];
	}

	if ($service_phid === null) {
	throw new Exception(
	pht(
	'When creating a new Almanac binding via the Conduit API, you '.
	'must provide a "service" transaction to select a service to bind.'));
	}

	$service = id(new AlmanacServiceQuery())
	->setViewer($this->getViewer())
	->withPHIDs(array($service_phid))
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->executeOne();
	if (!$service) {
	throw new Exception(
	pht(
	'Service "%s" is unrecognized, restricted, or you do not have '.
	'permission to edit it.',
	$service_phid));
	}

	$this->setService($service);

	return $this->newEditableObject();
	}

	protected function newObjectQuery() {
	return id(new AlmanacBindingQuery())
	->needProperties(true);
	}

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

	protected function getObjectCreateButtonText($object) {
	return pht('Create Binding');
	}

	protected function getObjectEditTitleText($object) {
	return pht('Edit Binding');
	}

	protected function getObjectEditShortText($object) {
	return pht('Edit Binding');
	}

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

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

	protected function getEditorURI() {
	return '/almanac/binding/edit/';
	}

	protected function getObjectCreateCancelURI($object) {
	return '/almanac/binding/';
	}

	protected function getObjectViewURI($object) {
	return $object->getURI();
	}

	protected function buildCustomEditFields($object) {
	return array(
	id(new PhabricatorTextEditField())
	->setKey('service')
	->setLabel(pht('Service'))
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setTransactionType(
	AlmanacBindingServiceTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Service to create a binding for.'))
	->setConduitDescription(pht('Select the service to bind.'))
	->setConduitTypeDescription(pht('Service PHID.'))
	->setValue($object->getServicePHID()),
	id(new PhabricatorTextEditField())
	->setKey('interface')
	->setLabel(pht('Interface'))
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setTransactionType(
	AlmanacBindingInterfaceTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Interface to bind the service to.'))
	->setConduitDescription(pht('Set the interface to bind.'))
	->setConduitTypeDescription(pht('Interface PHID.'))
	->setValue($object->getInterfacePHID()),
	id(new PhabricatorBoolEditField())
	->setKey('disabled')
	->setLabel(pht('Disabled'))
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setTransactionType(
	AlmanacBindingDisableTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Disable or enable the binding.'))
	->setConduitDescription(pht('Disable or enable the binding.'))
	->setConduitTypeDescription(pht('True to disable the binding.'))
	->setValue($object->getIsDisabled())
	->setOptions(
	pht('Enable Binding'),
	pht('Disable Binding')),
	);
	}

	}
	diff --git a/src/applications/almanac/editor/AlmanacInterfaceEditEngine.php b/src/applications/almanac/editor/AlmanacInterfaceEditEngine.php
	index 30c371d6f9..ca57113bf2 100644
	--- a/src/applications/almanac/editor/AlmanacInterfaceEditEngine.php
	+++ b/src/applications/almanac/editor/AlmanacInterfaceEditEngine.php
	@@ -1,186 +1,186 @@
	<?php

	final class AlmanacInterfaceEditEngine
	extends PhabricatorEditEngine {

	const ENGINECONST = 'almanac.interface';

	private $device;

	public function setDevice(AlmanacDevice $device) {
	$this->device = $device;
	return $this;
	}

	public function getDevice() {
	if (!$this->device) {
	throw new PhutilInvalidStateException('setDevice');
	}
	return $this->device;
	}

	public function isEngineConfigurable() {
	return false;
	}

	public function getEngineName() {
	return pht('Almanac Interfaces');
	}

	public function getSummaryHeader() {
	return pht('Edit Almanac Interface Configurations');
	}

	public function getSummaryText() {
	return pht('This engine is used to edit Almanac interfaces.');
	}

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

	protected function newEditableObject() {
	$interface = AlmanacInterface::initializeNewInterface();

	$device = $this->getDevice();
	$interface
	->setDevicePHID($device->getPHID())
	->attachDevice($device);

	return $interface;
	}

	protected function newEditableObjectForDocumentation() {
	$this->setDevice(new AlmanacDevice());
	return $this->newEditableObject();
	}

	protected function newEditableObjectFromConduit(array $raw_xactions) {
	$device_phid = null;
	foreach ($raw_xactions as $raw_xaction) {
	if ($raw_xaction['type'] !== 'device') {
	continue;
	}

	$device_phid = $raw_xaction['value'];
	}

	if ($device_phid === null) {
	throw new Exception(
	pht(
	'When creating a new Almanac interface via the Conduit API, you '.
	'must provide a "device" transaction to select a device.'));
	}

	$device = id(new AlmanacDeviceQuery())
	->setViewer($this->getViewer())
	->withPHIDs(array($device_phid))
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->executeOne();
	if (!$device) {
	throw new Exception(
	pht(
	'Device "%s" is unrecognized, restricted, or you do not have '.
	'permission to edit it.',
	$device_phid));
	}

	$this->setDevice($device);

	return $this->newEditableObject();
	}

	protected function newObjectQuery() {
	return new AlmanacInterfaceQuery();
	}

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

	protected function getObjectCreateButtonText($object) {
	return pht('Create Interface');
	}

	protected function getObjectEditTitleText($object) {
	return pht('Edit Interface');
	}

	protected function getObjectEditShortText($object) {
	return pht('Edit Interface');
	}

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

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

	protected function getEditorURI() {
	return '/almanac/interface/edit/';
	}

	protected function getObjectCreateCancelURI($object) {
	if ($this->getDevice()) {
	return $this->getDevice()->getURI();
	}
	return '/almanac/interface/';
	}

	protected function getObjectViewURI($object) {
	return $object->getDevice()->getURI();
	}

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

	// TODO: Some day, this should be a datasource.
	$networks = id(new AlmanacNetworkQuery())
	->setViewer($viewer)
	->execute();
	$network_map = mpull($networks, 'getName', 'getPHID');

	return array(
	id(new PhabricatorTextEditField())
	->setKey('device')
	->setLabel(pht('Device'))
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setTransactionType(
	AlmanacInterfaceDeviceTransaction::TRANSACTIONTYPE)
	->setDescription(pht('When creating an interface, set the device.'))
	->setConduitDescription(pht('Set the device.'))
	->setConduitTypeDescription(pht('Device PHID.'))
	->setValue($object->getDevicePHID()),
	id(new PhabricatorSelectEditField())
	->setKey('network')
	->setLabel(pht('Network'))
	->setDescription(pht('Network for the interface.'))
	->setTransactionType(
	AlmanacInterfaceNetworkTransaction::TRANSACTIONTYPE)
	->setValue($object->getNetworkPHID())
	->setOptions($network_map),
	id(new PhabricatorTextEditField())
	->setKey('address')
	->setLabel(pht('Address'))
	->setDescription(pht('Address of the service.'))
	->setTransactionType(
	AlmanacInterfaceAddressTransaction::TRANSACTIONTYPE)
	->setIsRequired(true)
	->setValue($object->getAddress()),
	id(new PhabricatorIntEditField())
	->setKey('port')
	->setLabel(pht('Port'))
	->setDescription(pht('Port of the service.'))
	->setTransactionType(AlmanacInterfacePortTransaction::TRANSACTIONTYPE)
	->setIsRequired(true)
	->setValue($object->getPort()),
	);
	}

	}
	diff --git a/src/applications/almanac/editor/AlmanacServiceEditEngine.php b/src/applications/almanac/editor/AlmanacServiceEditEngine.php
	index 00e54962b3..b63075543f 100644
	--- a/src/applications/almanac/editor/AlmanacServiceEditEngine.php
	+++ b/src/applications/almanac/editor/AlmanacServiceEditEngine.php
	@@ -1,149 +1,149 @@
	<?php

	final class AlmanacServiceEditEngine
	extends PhabricatorEditEngine {

	const ENGINECONST = 'almanac.service';

	private $serviceType;

	public function setServiceType($service_type) {
	$this->serviceType = $service_type;
	return $this;
	}

	public function getServiceType() {
	return $this->serviceType;
	}

	public function isEngineConfigurable() {
	return false;
	}

	public function getEngineName() {
	return pht('Almanac Services');
	}

	public function getSummaryHeader() {
	return pht('Edit Almanac Service Configurations');
	}

	public function getSummaryText() {
	return pht('This engine is used to edit Almanac services.');
	}

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

	protected function newEditableObject() {
	$service_type = $this->getServiceType();
	return AlmanacService::initializeNewService($service_type);
	}

	protected function newEditableObjectFromConduit(array $raw_xactions) {
	$type = null;
	foreach ($raw_xactions as $raw_xaction) {
	if ($raw_xaction['type'] !== 'type') {
	continue;
	}

	$type = $raw_xaction['value'];
	}

	if ($type === null) {
	throw new Exception(
	pht(
	'When creating a new Almanac service via the Conduit API, you '.
	'must provide a "type" transaction to select a type.'));
	}

	$map = AlmanacServiceType::getAllServiceTypes();
	if (!isset($map[$type])) {
	throw new Exception(
	pht(
	'Service type "%s" is unrecognized. Valid types are: %s.',
	$type,
	implode(', ', array_keys($map))));
	}

	$this->setServiceType($type);

	return $this->newEditableObject();
	}

	protected function newEditableObjectForDocumentation() {
	$service_type = new AlmanacCustomServiceType();
	$this->setServiceType($service_type->getServiceTypeConstant());
	return $this->newEditableObject();
	}

	protected function newObjectQuery() {
	return id(new AlmanacServiceQuery())
	->needProperties(true);
	}

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

	protected function getObjectCreateButtonText($object) {
	return pht('Create Service');
	}

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

	protected function getObjectEditShortText($object) {
	return pht('Edit Service');
	}

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

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

	protected function getEditorURI() {
	return '/almanac/service/edit/';
	}

	protected function getObjectCreateCancelURI($object) {
	return '/almanac/service/';
	}

	protected function getObjectViewURI($object) {
	return $object->getURI();
	}

	protected function getCreateNewObjectPolicy() {
	return $this->getApplication()->getPolicy(
	AlmanacCreateServicesCapability::CAPABILITY);
	}

	protected function buildCustomEditFields($object) {
	return array(
	id(new PhabricatorTextEditField())
	->setKey('name')
	->setLabel(pht('Name'))
	->setDescription(pht('Name of the service.'))
	->setTransactionType(AlmanacServiceNameTransaction::TRANSACTIONTYPE)
	->setIsRequired(true)
	->setValue($object->getName()),
	id(new PhabricatorTextEditField())
	->setKey('type')
	->setLabel(pht('Type'))
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setTransactionType(
	AlmanacServiceTypeTransaction::TRANSACTIONTYPE)
	->setDescription(pht('When creating a service, set the type.'))
	->setConduitDescription(pht('Set the service type.'))
	->setConduitTypeDescription(pht('Service type.'))
	->setValue($object->getServiceType()),
	);
	}

	}
	diff --git a/src/applications/almanac/engineextension/AlmanacPropertiesEditEngineExtension.php b/src/applications/almanac/engineextension/AlmanacPropertiesEditEngineExtension.php
	index 965c193f40..425ee04b3c 100644
	--- a/src/applications/almanac/engineextension/AlmanacPropertiesEditEngineExtension.php
	+++ b/src/applications/almanac/engineextension/AlmanacPropertiesEditEngineExtension.php
	@@ -1,44 +1,44 @@
	<?php

	final class AlmanacPropertiesEditEngineExtension
	extends PhabricatorEditEngineExtension {

	const EXTENSIONKEY = 'almanac.properties';

	public function isExtensionEnabled() {
	return true;
	}

	public function getExtensionName() {
	return pht('Almanac Properties');
	}

	public function supportsObject(
	PhabricatorEditEngine $engine,
	PhabricatorApplicationTransactionInterface $object) {
	return ($object instanceof AlmanacPropertyInterface);
	}

	public function buildCustomEditFields(
	PhabricatorEditEngine $engine,
	PhabricatorApplicationTransactionInterface $object) {

	return array(
	id(new AlmanacSetPropertyEditField())
	->setKey('property.set')
	->setTransactionType($object->getAlmanacPropertySetTransactionType())
	->setConduitDescription(
	pht('Pass a map of values to set one or more properties.'))
	->setConduitTypeDescription(pht('Map of property names to values.'))
	- ->setIsConduitOnly(true),
	+ ->setIsFormField(false),
	id(new AlmanacDeletePropertyEditField())
	->setKey('property.delete')
	->setTransactionType($object->getAlmanacPropertyDeleteTransactionType())
	->setConduitDescription(
	pht('Pass a list of property names to delete properties.'))
	->setConduitTypeDescription(pht('List of property names.'))
	- ->setIsConduitOnly(true),
	+ ->setIsFormField(false),
	);
	}

	}
	diff --git a/src/applications/badges/editor/PhabricatorBadgesEditEngine.php b/src/applications/badges/editor/PhabricatorBadgesEditEngine.php
	index e7a441343c..721184852c 100644
	--- a/src/applications/badges/editor/PhabricatorBadgesEditEngine.php
	+++ b/src/applications/badges/editor/PhabricatorBadgesEditEngine.php
	@@ -1,147 +1,147 @@
	<?php

	final class PhabricatorBadgesEditEngine
	extends PhabricatorEditEngine {

	const ENGINECONST = 'badges.badge';

	public function getEngineName() {
	return pht('Badges');
	}

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

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

	public function getSummaryText() {
	return pht('Configure creation and editing forms in Badges.');
	}

	public function isEngineConfigurable() {
	return false;
	}

	protected function newEditableObject() {
	return PhabricatorBadgesBadge::initializeNewBadge($this->getViewer());
	}

	protected function newObjectQuery() {
	return new PhabricatorBadgesQuery();
	}

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

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

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

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

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

	protected function getObjectCreateCancelURI($object) {
	return $this->getApplication()->getApplicationURI('/');
	}

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

	protected function getCommentViewHeaderText($object) {
	return pht('Render Honors');
	}

	protected function getCommentViewButtonText($object) {
	return pht('Salute');
	}

	protected function getObjectViewURI($object) {
	return $object->getViewURI();
	}

	protected function getCreateNewObjectPolicy() {
	return $this->getApplication()->getPolicy(
	PhabricatorBadgesCreateCapability::CAPABILITY);
	}

	protected function buildCustomEditFields($object) {

	return array(
	id(new PhabricatorTextEditField())
	->setKey('name')
	->setLabel(pht('Name'))
	->setDescription(pht('Badge name.'))
	->setConduitTypeDescription(pht('New badge name.'))
	->setTransactionType(
	PhabricatorBadgesBadgeNameTransaction::TRANSACTIONTYPE)
	->setValue($object->getName())
	->setIsRequired(true),
	id(new PhabricatorTextEditField())
	->setKey('flavor')
	->setLabel(pht('Flavor Text'))
	->setDescription(pht('Short description of the badge.'))
	->setConduitTypeDescription(pht('New badge flavor.'))
	->setValue($object->getFlavor())
	->setTransactionType(
	PhabricatorBadgesBadgeFlavorTransaction::TRANSACTIONTYPE),
	id(new PhabricatorIconSetEditField())
	->setKey('icon')
	->setLabel(pht('Icon'))
	->setIconSet(new PhabricatorBadgesIconSet())
	->setTransactionType(
	PhabricatorBadgesBadgeIconTransaction::TRANSACTIONTYPE)
	->setConduitDescription(pht('Change the badge icon.'))
	->setConduitTypeDescription(pht('New badge icon.'))
	->setValue($object->getIcon()),
	id(new PhabricatorSelectEditField())
	->setKey('quality')
	->setLabel(pht('Quality'))
	->setDescription(pht('Color and rarity of the badge.'))
	->setConduitTypeDescription(pht('New badge quality.'))
	->setValue($object->getQuality())
	->setTransactionType(
	PhabricatorBadgesBadgeQualityTransaction::TRANSACTIONTYPE)
	->setOptions(PhabricatorBadgesQuality::getDropdownQualityMap()),
	id(new PhabricatorRemarkupEditField())
	->setKey('description')
	->setLabel(pht('Description'))
	->setDescription(pht('Badge long description.'))
	->setConduitTypeDescription(pht('New badge description.'))
	->setTransactionType(
	PhabricatorBadgesBadgeDescriptionTransaction::TRANSACTIONTYPE)
	->setValue($object->getDescription()),
	id(new PhabricatorUsersEditField())
	->setKey('award')
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setDescription(pht('New badge award recipients.'))
	->setConduitTypeDescription(pht('New badge award recipients.'))
	->setTransactionType(
	PhabricatorBadgesBadgeAwardTransaction::TRANSACTIONTYPE)
	->setLabel(pht('Award Recipients')),
	id(new PhabricatorUsersEditField())
	->setKey('revoke')
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setDescription(pht('Revoke badge award recipients.'))
	->setConduitTypeDescription(pht('Revoke badge award recipients.'))
	->setTransactionType(
	PhabricatorBadgesBadgeRevokeTransaction::TRANSACTIONTYPE)
	->setLabel(pht('Revoke Recipients')),

	);
	}

	}
	diff --git a/src/applications/calendar/editor/PhabricatorCalendarEventEditEngine.php b/src/applications/calendar/editor/PhabricatorCalendarEventEditEngine.php
	index a9eab9376a..1b23b13fbf 100644
	--- a/src/applications/calendar/editor/PhabricatorCalendarEventEditEngine.php
	+++ b/src/applications/calendar/editor/PhabricatorCalendarEventEditEngine.php
	@@ -1,419 +1,419 @@
	<?php

	final class PhabricatorCalendarEventEditEngine
	extends PhabricatorEditEngine {

	const ENGINECONST = 'calendar.event';

	private $rawTransactions;
	private $seriesEditMode = self::MODE_THIS;

	const MODE_THIS = 'this';
	const MODE_FUTURE = 'future';

	public function setSeriesEditMode($series_edit_mode) {
	$this->seriesEditMode = $series_edit_mode;
	return $this;
	}

	public function getSeriesEditMode() {
	return $this->seriesEditMode;
	}

	public function getEngineName() {
	return pht('Calendar Events');
	}

	public function getSummaryHeader() {
	return pht('Configure Calendar Event Forms');
	}

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

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

	protected function newEditableObject() {
	return PhabricatorCalendarEvent::initializeNewCalendarEvent(
	$this->getViewer());
	}

	protected function newObjectQuery() {
	return new PhabricatorCalendarEventQuery();
	}

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

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

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

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

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

	protected function getObjectViewURI($object) {
	return $object->getURI();
	}

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

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

	if ($this->getIsCreate()) {
	$invitee_phids = array($viewer->getPHID());
	} else {
	$invitee_phids = $object->getInviteePHIDsForEdit();
	}

	$frequency_map = PhabricatorCalendarEvent::getFrequencyMap();
	$frequency_options = ipull($frequency_map, 'label');

	$rrule = $object->newRecurrenceRule();
	if ($rrule) {
	$frequency = $rrule->getFrequency();
	} else {
	$frequency = null;
	}

	// At least for now, just hide "Invitees" when editing all future events.
	// This may eventually deserve a more nuanced approach.
	$is_future = ($this->getSeriesEditMode() == self::MODE_FUTURE);

	$fields = array(
	id(new PhabricatorTextEditField())
	->setKey('name')
	->setLabel(pht('Name'))
	->setDescription(pht('Name of the event.'))
	->setIsRequired(true)
	->setTransactionType(
	PhabricatorCalendarEventNameTransaction::TRANSACTIONTYPE)
	->setConduitDescription(pht('Rename the event.'))
	->setConduitTypeDescription(pht('New event name.'))
	->setValue($object->getName()),
	id(new PhabricatorBoolEditField())
	->setIsLockable(false)
	->setIsDefaultable(false)
	->setKey('isAllDay')
	->setOptions(pht('Normal Event'), pht('All Day Event'))
	->setAsCheckbox(true)
	->setTransactionType(
	PhabricatorCalendarEventAllDayTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Marks this as an all day event.'))
	->setConduitDescription(pht('Make the event an all day event.'))
	->setConduitTypeDescription(pht('Mark the event as an all day event.'))
	->setValue($object->getIsAllDay()),
	id(new PhabricatorEpochEditField())
	->setKey('start')
	->setLabel(pht('Start'))
	->setIsLockable(false)
	->setIsDefaultable(false)
	->setTransactionType(
	PhabricatorCalendarEventStartDateTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Start time of the event.'))
	->setConduitDescription(pht('Change the start time of the event.'))
	->setConduitTypeDescription(pht('New event start time.'))
	->setValue($object->getStartDateTimeEpoch()),
	id(new PhabricatorEpochEditField())
	->setKey('end')
	->setLabel(pht('End'))
	->setIsLockable(false)
	->setIsDefaultable(false)
	->setTransactionType(
	PhabricatorCalendarEventEndDateTransaction::TRANSACTIONTYPE)
	->setDescription(pht('End time of the event.'))
	->setConduitDescription(pht('Change the end time of the event.'))
	->setConduitTypeDescription(pht('New event end time.'))
	->setValue($object->newEndDateTimeForEdit()->getEpoch()),
	id(new PhabricatorBoolEditField())
	->setKey('cancelled')
	->setOptions(pht('Active'), pht('Cancelled'))
	->setLabel(pht('Cancelled'))
	->setDescription(pht('Cancel the event.'))
	->setTransactionType(
	PhabricatorCalendarEventCancelTransaction::TRANSACTIONTYPE)
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setConduitDescription(pht('Cancel or restore the event.'))
	->setConduitTypeDescription(pht('True to cancel the event.'))
	->setValue($object->getIsCancelled()),
	id(new PhabricatorUsersEditField())
	->setIsLockable(false)
	->setIsDefaultable(false)
	->setKey('hostPHID')
	->setAliases(array('host'))
	->setLabel(pht('Host'))
	->setDescription(pht('Host of the event.'))
	->setTransactionType(
	PhabricatorCalendarEventHostTransaction::TRANSACTIONTYPE)
	- ->setIsConduitOnly($this->getIsCreate())
	+ ->setIsFormField(!$this->getIsCreate())
	->setConduitDescription(pht('Change the host of the event.'))
	->setConduitTypeDescription(pht('New event host.'))
	->setSingleValue($object->getHostPHID()),
	id(new PhabricatorDatasourceEditField())
	->setIsLockable(false)
	->setIsDefaultable(false)
	->setIsHidden($is_future)
	->setKey('inviteePHIDs')
	->setAliases(array('invite', 'invitee', 'invitees', 'inviteePHID'))
	->setLabel(pht('Invitees'))
	->setDatasource(new PhabricatorMetaMTAMailableDatasource())
	->setTransactionType(
	PhabricatorCalendarEventInviteTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Users invited to the event.'))
	->setConduitDescription(pht('Change invited users.'))
	->setConduitTypeDescription(pht('New event invitees.'))
	->setValue($invitee_phids)
	->setCommentActionLabel(pht('Change Invitees')),
	id(new PhabricatorRemarkupEditField())
	->setKey('description')
	->setLabel(pht('Description'))
	->setDescription(pht('Description of the event.'))
	->setTransactionType(
	PhabricatorCalendarEventDescriptionTransaction::TRANSACTIONTYPE)
	->setConduitDescription(pht('Update the event description.'))
	->setConduitTypeDescription(pht('New event description.'))
	->setValue($object->getDescription()),
	id(new PhabricatorIconSetEditField())
	->setKey('icon')
	->setLabel(pht('Icon'))
	->setIconSet(new PhabricatorCalendarIconSet())
	->setTransactionType(
	PhabricatorCalendarEventIconTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Event icon.'))
	->setConduitDescription(pht('Change the event icon.'))
	->setConduitTypeDescription(pht('New event icon.'))
	->setValue($object->getIcon()),

	// NOTE: We're being a little sneaky here. This field is hidden and
	// always has the value "true", so it makes the event recurring when you
	// submit a form which contains the field. Then we put the the field on
	// the "recurring" page in the "Make Recurring" dialog to simplify the
	// workflow. This is still normal, explicit field from the perspective
	// of the API.

	id(new PhabricatorBoolEditField())
	->setIsHidden(true)
	->setIsLockable(false)
	->setIsDefaultable(false)
	->setKey('isRecurring')
	->setLabel(pht('Recurring'))
	->setOptions(pht('One-Time Event'), pht('Recurring Event'))
	->setTransactionType(
	PhabricatorCalendarEventRecurringTransaction::TRANSACTIONTYPE)
	->setDescription(pht('One time or recurring event.'))
	->setConduitDescription(pht('Make the event recurring.'))
	->setConduitTypeDescription(pht('Mark the event as a recurring event.'))
	->setValue(true),
	id(new PhabricatorSelectEditField())
	->setIsLockable(false)
	->setIsDefaultable(false)
	->setKey('frequency')
	->setLabel(pht('Frequency'))
	->setOptions($frequency_options)
	->setTransactionType(
	PhabricatorCalendarEventFrequencyTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Recurring event frequency.'))
	->setConduitDescription(pht('Change the event frequency.'))
	->setConduitTypeDescription(pht('New event frequency.'))
	->setValue($frequency),
	id(new PhabricatorEpochEditField())
	->setIsLockable(false)
	->setIsDefaultable(false)
	->setAllowNull(true)
	->setHideTime($object->getIsAllDay())
	->setKey('until')
	->setLabel(pht('Repeat Until'))
	->setTransactionType(
	PhabricatorCalendarEventUntilDateTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Last instance of the event.'))
	->setConduitDescription(pht('Change when the event repeats until.'))
	->setConduitTypeDescription(pht('New final event time.'))
	->setValue($object->getUntilDateTimeEpoch()),
	);

	return $fields;
	}

	protected function willBuildEditForm($object, array $fields) {
	$all_day_field = idx($fields, 'isAllDay');
	$start_field = idx($fields, 'start');
	$end_field = idx($fields, 'end');

	if ($all_day_field) {
	$is_all_day = $all_day_field->getValueForTransaction();

	$control_ids = array();
	if ($start_field) {
	$control_ids[] = $start_field->getControlID();
	}
	if ($end_field) {
	$control_ids[] = $end_field->getControlID();
	}

	Javelin::initBehavior(
	'event-all-day',
	array(
	'allDayID' => $all_day_field->getControlID(),
	'controlIDs' => $control_ids,
	));

	} else {
	$is_all_day = $object->getIsAllDay();
	}

	if ($is_all_day) {
	if ($start_field) {
	$start_field->setHideTime(true);
	}

	if ($end_field) {
	$end_field->setHideTime(true);
	}
	}

	return $fields;
	}

	protected function newPages($object) {
	// Controls for event recurrence behavior go on a separate page which we
	// put in a dialog. This simplifies event creation in the common case.

	return array(
	id(new PhabricatorEditPage())
	->setKey('core')
	->setLabel(pht('Core'))
	->setIsDefault(true),
	id(new PhabricatorEditPage())
	->setKey('recurring')
	->setLabel(pht('Recurrence'))
	->setFieldKeys(
	array(
	'isRecurring',
	'frequency',
	'until',
	)),
	);
	}

	protected function willApplyTransactions($object, array $xactions) {
	$viewer = $this->getViewer();

	$is_parent = $object->isParentEvent();
	$is_child = $object->isChildEvent();
	$is_future = ($this->getSeriesEditMode() === self::MODE_FUTURE);

	// Figure out which transactions we can apply to the whole series of events.
	// Some transactions (like comments) can never be bulk applied.
	$inherited_xactions = array();
	foreach ($xactions as $xaction) {
	$modular_type = $xaction->getModularType();
	if (!($modular_type instanceof PhabricatorCalendarEventTransactionType)) {
	continue;
	}

	$inherited_edit = $modular_type->isInheritedEdit();
	if ($inherited_edit) {
	$inherited_xactions[] = $xaction;
	}
	}
	$this->rawTransactions = $this->cloneTransactions($inherited_xactions);

	$must_fork = ($is_child && $is_future) \|\|
	($is_parent && !$is_future);

	// We don't need to fork when editing a parent event if none of the edits
	// can transfer to child events. For example, commenting on a parent is
	// fine.
	if ($is_parent && !$is_future) {
	if (!$inherited_xactions) {
	$must_fork = false;
	}
	}

	if ($must_fork) {
	$fork_target = $object->loadForkTarget($viewer);
	if ($fork_target) {
	$fork_xaction = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(
	PhabricatorCalendarEventForkTransaction::TRANSACTIONTYPE)
	->setNewValue(true);

	if ($fork_target->getPHID() == $object->getPHID()) {
	// We're forking the object itself, so just slip it into the
	// transactions we're going to apply.
	array_unshift($xactions, $fork_xaction);
	} else {
	// Otherwise, we're forking a different object, so we have to
	// apply that separately.
	$this->applyTransactions($fork_target, array($fork_xaction));
	}
	}
	}

	return $xactions;
	}

	protected function didApplyTransactions($object, array $xactions) {
	$viewer = $this->getViewer();

	if ($this->getSeriesEditMode() !== self::MODE_FUTURE) {
	return;
	}

	$targets = $object->loadFutureEvents($viewer);
	if (!$targets) {
	return;
	}

	foreach ($targets as $target) {
	$apply = $this->cloneTransactions($this->rawTransactions);
	$this->applyTransactions($target, $apply);
	}
	}

	private function applyTransactions($target, array $xactions) {
	$viewer = $this->getViewer();

	// TODO: This isn't the most accurate source we could use, but this mode
	// is web-only for now.
	$content_source = PhabricatorContentSource::newForSource(
	PhabricatorWebContentSource::SOURCECONST);

	$editor = id(new PhabricatorCalendarEventEditor())
	->setActor($viewer)
	->setContentSource($content_source)
	->setContinueOnNoEffect(true)
	->setContinueOnMissingFields(true);

	try {
	$editor->applyTransactions($target, $xactions);
	} catch (PhabricatorApplicationTransactionValidationException $ex) {
	// Just ignore any issues we run into.
	}
	}

	private function cloneTransactions(array $xactions) {
	$result = array();
	foreach ($xactions as $xaction) {
	$result[] = clone $xaction;
	}
	return $result;
	}

	}
	diff --git a/src/applications/calendar/editor/PhabricatorCalendarExportEditEngine.php b/src/applications/calendar/editor/PhabricatorCalendarExportEditEngine.php
	index 8cd35e7323..bc8fc360c6 100644
	--- a/src/applications/calendar/editor/PhabricatorCalendarExportEditEngine.php
	+++ b/src/applications/calendar/editor/PhabricatorCalendarExportEditEngine.php
	@@ -1,133 +1,133 @@
	<?php

	final class PhabricatorCalendarExportEditEngine
	extends PhabricatorEditEngine {

	const ENGINECONST = 'calendar.export';

	public function getEngineName() {
	return pht('Calendar Exports');
	}

	public function isEngineConfigurable() {
	return false;
	}

	public function getSummaryHeader() {
	return pht('Configure Calendar Export Forms');
	}

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

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

	protected function newEditableObject() {
	return PhabricatorCalendarExport::initializeNewCalendarExport(
	$this->getViewer());
	}

	protected function newObjectQuery() {
	return new PhabricatorCalendarExportQuery();
	}

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

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

	protected function getObjectEditShortText($object) {
	return pht('Export %d', $object->getID());
	}

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

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

	protected function getObjectViewURI($object) {
	return $object->getURI();
	}

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

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

	$export_modes = PhabricatorCalendarExport::getAvailablePolicyModes();
	$export_modes = array_fuse($export_modes);

	$current_mode = $object->getPolicyMode();
	if (empty($export_modes[$current_mode])) {
	array_unshift($export_modes, $current_mode);
	}

	$mode_options = array();
	foreach ($export_modes as $export_mode) {
	$mode_name = PhabricatorCalendarExport::getPolicyModeName($export_mode);
	$mode_summary = PhabricatorCalendarExport::getPolicyModeSummary(
	$export_mode);
	$mode_options[$export_mode] = pht('%s: %s', $mode_name, $mode_summary);
	}

	$fields = array(
	id(new PhabricatorTextEditField())
	->setKey('name')
	->setLabel(pht('Name'))
	->setDescription(pht('Name of the export.'))
	->setIsRequired(true)
	->setTransactionType(
	PhabricatorCalendarExportNameTransaction::TRANSACTIONTYPE)
	->setConduitDescription(pht('Rename the export.'))
	->setConduitTypeDescription(pht('New export name.'))
	->setValue($object->getName()),
	id(new PhabricatorBoolEditField())
	->setKey('disabled')
	->setOptions(pht('Active'), pht('Disabled'))
	->setLabel(pht('Disabled'))
	->setDescription(pht('Disable the export.'))
	->setTransactionType(
	PhabricatorCalendarExportDisableTransaction::TRANSACTIONTYPE)
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setConduitDescription(pht('Disable or restore the export.'))
	->setConduitTypeDescription(pht('True to cancel the export.'))
	->setValue($object->getIsDisabled()),
	id(new PhabricatorTextEditField())
	->setKey('queryKey')
	->setLabel(pht('Query Key'))
	->setDescription(pht('Query to execute.'))
	->setIsRequired(true)
	->setTransactionType(
	PhabricatorCalendarExportQueryKeyTransaction::TRANSACTIONTYPE)
	->setConduitDescription(pht('Change the export query key.'))
	->setConduitTypeDescription(pht('New export query key.'))
	->setValue($object->getQueryKey()),
	id(new PhabricatorSelectEditField())
	->setKey('mode')
	->setLabel(pht('Mode'))
	->setTransactionType(
	PhabricatorCalendarExportModeTransaction::TRANSACTIONTYPE)
	->setOptions($mode_options)
	->setDescription(pht('Change the policy mode for the export.'))
	->setConduitDescription(pht('Adjust export mode.'))
	->setConduitTypeDescription(pht('New export mode.'))
	->setValue($current_mode),

	);

	return $fields;
	}


	}
	diff --git a/src/applications/calendar/editor/PhabricatorCalendarImportEditEngine.php b/src/applications/calendar/editor/PhabricatorCalendarImportEditEngine.php
	index 90b4962ca9..7be3969671 100644
	--- a/src/applications/calendar/editor/PhabricatorCalendarImportEditEngine.php
	+++ b/src/applications/calendar/editor/PhabricatorCalendarImportEditEngine.php
	@@ -1,155 +1,155 @@
	<?php

	final class PhabricatorCalendarImportEditEngine
	extends PhabricatorEditEngine {

	const ENGINECONST = 'calendar.import';

	private $importEngine;

	public function setImportEngine(PhabricatorCalendarImportEngine $engine) {
	$this->importEngine = $engine;
	return $this;
	}

	public function getImportEngine() {
	return $this->importEngine;
	}

	public function getEngineName() {
	return pht('Calendar Imports');
	}

	public function isEngineConfigurable() {
	return false;
	}

	public function getSummaryHeader() {
	return pht('Configure Calendar Import Forms');
	}

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

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

	protected function newEditableObject() {
	$viewer = $this->getViewer();
	$engine = $this->getImportEngine();

	return PhabricatorCalendarImport::initializeNewCalendarImport(
	$viewer,
	$engine);
	}

	protected function newObjectQuery() {
	return new PhabricatorCalendarImportQuery();
	}

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

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

	protected function getObjectEditShortText($object) {
	return pht('Import %d', $object->getID());
	}

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

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

	protected function getObjectViewURI($object) {
	return $object->getURI();
	}

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

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

	$engine = $object->getEngine();
	$can_trigger = $engine->supportsTriggers($object);

	$fields = array(
	id(new PhabricatorTextEditField())
	->setKey('name')
	->setLabel(pht('Name'))
	->setDescription(pht('Name of the import.'))
	->setTransactionType(
	PhabricatorCalendarImportNameTransaction::TRANSACTIONTYPE)
	->setConduitDescription(pht('Rename the import.'))
	->setConduitTypeDescription(pht('New import name.'))
	->setPlaceholder($object->getDisplayName())
	->setValue($object->getName()),
	id(new PhabricatorBoolEditField())
	->setKey('disabled')
	->setOptions(pht('Active'), pht('Disabled'))
	->setLabel(pht('Disabled'))
	->setDescription(pht('Disable the import.'))
	->setTransactionType(
	PhabricatorCalendarImportDisableTransaction::TRANSACTIONTYPE)
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setConduitDescription(pht('Disable or restore the import.'))
	->setConduitTypeDescription(pht('True to cancel the import.'))
	->setValue($object->getIsDisabled()),
	id(new PhabricatorBoolEditField())
	->setKey('delete')
	->setLabel(pht('Delete Imported Events'))
	->setDescription(pht('Delete all events from this source.'))
	->setTransactionType(
	PhabricatorCalendarImportDisableTransaction::TRANSACTIONTYPE)
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setConduitDescription(pht('Disable or restore the import.'))
	->setConduitTypeDescription(pht('True to delete imported events.'))
	->setValue(false),
	id(new PhabricatorBoolEditField())
	->setKey('reload')
	->setLabel(pht('Reload Import'))
	->setDescription(pht('Reload events imported from this source.'))
	->setTransactionType(
	PhabricatorCalendarImportDisableTransaction::TRANSACTIONTYPE)
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setConduitDescription(pht('Disable or restore the import.'))
	->setConduitTypeDescription(pht('True to reload the import.'))
	->setValue(false),
	);

	if ($can_trigger) {
	$frequency_map = PhabricatorCalendarImport::getTriggerFrequencyMap();
	$frequency_options = ipull($frequency_map, 'name');

	$fields[] = id(new PhabricatorSelectEditField())
	->setKey('frequency')
	->setLabel(pht('Update Automatically'))
	->setDescription(pht('Configure an automatic update frequency.'))
	->setTransactionType(
	PhabricatorCalendarImportFrequencyTransaction::TRANSACTIONTYPE)
	->setConduitDescription(pht('Set the automatic update frequency.'))
	->setConduitTypeDescription(pht('Update frequency constant.'))
	->setValue($object->getTriggerFrequency())
	->setOptions($frequency_options);
	}

	$import_engine = $object->getEngine();
	foreach ($import_engine->newEditEngineFields($this, $object) as $field) {
	$fields[] = $field;
	}

	return $fields;
	}


	}
	diff --git a/src/applications/conpherence/editor/ConpherenceEditEngine.php b/src/applications/conpherence/editor/ConpherenceEditEngine.php
	index 91cd8fd081..f5f850e637 100644
	--- a/src/applications/conpherence/editor/ConpherenceEditEngine.php
	+++ b/src/applications/conpherence/editor/ConpherenceEditEngine.php
	@@ -1,118 +1,118 @@
	<?php

	final class ConpherenceEditEngine
	extends PhabricatorEditEngine {

	const ENGINECONST = 'conpherence.thread';

	public function getEngineName() {
	return pht('Conpherence');
	}

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

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

	public function getSummaryText() {
	return pht('Configure creation and editing forms in Conpherence.');
	}

	protected function newEditableObject() {
	return ConpherenceThread::initializeNewRoom($this->getViewer());
	}

	protected function newObjectQuery() {
	return new ConpherenceThreadQuery();
	}

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

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

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

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

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

	protected function getObjectCreateCancelURI($object) {
	return $this->getApplication()->getApplicationURI('/');
	}

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

	protected function getObjectViewURI($object) {
	return $object->getURI();
	}

	public function isEngineConfigurable() {
	return false;
	}

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

	if ($this->getIsCreate()) {
	$participant_phids = array($viewer->getPHID());
	$initial_phids = array();
	} else {
	$participant_phids = $object->getParticipantPHIDs();
	$initial_phids = $participant_phids;
	}

	- // Only show participants on create or conduit, not edit
	- $conduit_only = !$this->getIsCreate();
	+ // Only show participants on create or conduit, not edit.
	+ $show_participants = (bool)$this->getIsCreate();

	return array(
	id(new PhabricatorTextEditField())
	->setKey('name')
	->setLabel(pht('Name'))
	->setDescription(pht('Room name.'))
	->setConduitTypeDescription(pht('New Room name.'))
	->setIsRequired(true)
	->setTransactionType(
	ConpherenceThreadTitleTransaction::TRANSACTIONTYPE)
	->setValue($object->getTitle()),

	id(new PhabricatorTextEditField())
	->setKey('topic')
	->setLabel(pht('Topic'))
	->setDescription(pht('Room topic.'))
	->setConduitTypeDescription(pht('New Room topic.'))
	->setTransactionType(
	ConpherenceThreadTopicTransaction::TRANSACTIONTYPE)
	->setValue($object->getTopic()),

	id(new PhabricatorUsersEditField())
	->setKey('participants')
	->setValue($participant_phids)
	->setInitialValue($initial_phids)
	- ->setIsConduitOnly($conduit_only)
	+ ->setIsFormField($show_participants)
	->setAliases(array('users', 'members', 'participants', 'userPHID'))
	->setDescription(pht('Room participants.'))
	->setUseEdgeTransactions(true)
	->setConduitTypeDescription(pht('New Room participants.'))
	->setTransactionType(
	ConpherenceThreadParticipantsTransaction::TRANSACTIONTYPE)
	->setLabel(pht('Initial Participants')),

	);
	}

	}
	diff --git a/src/applications/differential/editor/DifferentialRevisionEditEngine.php b/src/applications/differential/editor/DifferentialRevisionEditEngine.php
	index 0404bd6201..ffae7fab16 100644
	--- a/src/applications/differential/editor/DifferentialRevisionEditEngine.php
	+++ b/src/applications/differential/editor/DifferentialRevisionEditEngine.php
	@@ -1,346 +1,346 @@
	<?php

	final class DifferentialRevisionEditEngine
	extends PhabricatorEditEngine {

	private $diff;

	const ENGINECONST = 'differential.revision';

	const ACTIONGROUP_REVIEW = 'review';
	const ACTIONGROUP_REVISION = 'revision';

	public function getEngineName() {
	return pht('Revisions');
	}

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

	public function getSummaryText() {
	return pht(
	'Configure creation and editing revision forms in Differential.');
	}

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

	public function isEngineConfigurable() {
	return false;
	}

	protected function newEditableObject() {
	$viewer = $this->getViewer();
	return DifferentialRevision::initializeNewRevision($viewer);
	}

	protected function newObjectQuery() {
	return id(new DifferentialRevisionQuery())
	->needActiveDiffs(true)
	->needReviewers(true)
	->needReviewerAuthority(true);
	}

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

	protected function getObjectEditTitleText($object) {
	$monogram = $object->getMonogram();
	$title = $object->getTitle();

	$diff = $this->getDiff();
	if ($diff) {
	return pht('Update Revision %s: %s', $monogram, $title);
	} else {
	return pht('Edit Revision %s: %s', $monogram, $title);
	}
	}

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

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

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

	protected function getCommentViewButtonText($object) {
	if ($object->isDraft()) {
	return pht('Submit Quietly');
	}

	return parent::getCommentViewButtonText($object);
	}

	protected function getObjectViewURI($object) {
	return $object->getURI();
	}

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

	public function setDiff(DifferentialDiff $diff) {
	$this->diff = $diff;
	return $this;
	}

	public function getDiff() {
	return $this->diff;
	}

	protected function newCommentActionGroups() {
	return array(
	id(new PhabricatorEditEngineCommentActionGroup())
	->setKey(self::ACTIONGROUP_REVIEW)
	->setLabel(pht('Review Actions')),
	id(new PhabricatorEditEngineCommentActionGroup())
	->setKey(self::ACTIONGROUP_REVISION)
	->setLabel(pht('Revision Actions')),
	);
	}

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

	$plan_required = PhabricatorEnv::getEnvConfig(
	'differential.require-test-plan-field');
	$plan_enabled = $this->isCustomFieldEnabled(
	$object,
	'differential:test-plan');

	$diff = $this->getDiff();
	if ($diff) {
	$diff_phid = $diff->getPHID();
	} else {
	$diff_phid = null;
	}

	$is_create = $this->getIsCreate();
	$is_update = ($diff && !$is_create);

	$fields = array();

	$fields[] = id(new PhabricatorHandlesEditField())
	->setKey(DifferentialRevisionUpdateTransaction::EDITKEY)
	->setLabel(pht('Update Diff'))
	->setDescription(pht('New diff to create or update the revision with.'))
	->setConduitDescription(pht('Create or update a revision with a diff.'))
	->setConduitTypeDescription(pht('PHID of the diff.'))
	->setTransactionType(
	DifferentialRevisionUpdateTransaction::TRANSACTIONTYPE)
	->setHandleParameterType(new AphrontPHIDListHTTPParameterType())
	->setSingleValue($diff_phid)
	- ->setIsConduitOnly(!$diff)
	+ ->setIsFormField((bool)$diff)
	->setIsReorderable(false)
	->setIsDefaultable(false)
	->setIsInvisible(true)
	->setIsLockable(false);

	if ($is_update) {
	$fields[] = id(new PhabricatorInstructionsEditField())
	->setKey('update.help')
	->setValue(pht('Describe the updates you have made to the diff.'));
	$fields[] = id(new PhabricatorCommentEditField())
	->setKey('update.comment')
	->setLabel(pht('Comment'))
	->setTransactionType(PhabricatorTransactions::TYPE_COMMENT)
	->setIsWebOnly(true)
	->setDescription(pht('Comments providing context for the update.'));
	$fields[] = id(new PhabricatorSubmitEditField())
	->setKey('update.submit')
	->setValue($this->getObjectEditButtonText($object));
	$fields[] = id(new PhabricatorDividerEditField())
	->setKey('update.note');
	}

	$fields[] = id(new PhabricatorTextEditField())
	->setKey(DifferentialRevisionTitleTransaction::EDITKEY)
	->setLabel(pht('Title'))
	->setIsRequired(true)
	->setTransactionType(
	DifferentialRevisionTitleTransaction::TRANSACTIONTYPE)
	->setDescription(pht('The title of the revision.'))
	->setConduitDescription(pht('Retitle the revision.'))
	->setConduitTypeDescription(pht('New revision title.'))
	->setValue($object->getTitle());

	$fields[] = id(new PhabricatorRemarkupEditField())
	->setKey(DifferentialRevisionSummaryTransaction::EDITKEY)
	->setLabel(pht('Summary'))
	->setTransactionType(
	DifferentialRevisionSummaryTransaction::TRANSACTIONTYPE)
	->setDescription(pht('The summary of the revision.'))
	->setConduitDescription(pht('Change the revision summary.'))
	->setConduitTypeDescription(pht('New revision summary.'))
	->setValue($object->getSummary());

	if ($plan_enabled) {
	$fields[] = id(new PhabricatorRemarkupEditField())
	->setKey(DifferentialRevisionTestPlanTransaction::EDITKEY)
	->setLabel(pht('Test Plan'))
	->setIsRequired($plan_required)
	->setTransactionType(
	DifferentialRevisionTestPlanTransaction::TRANSACTIONTYPE)
	->setDescription(
	pht('Actions performed to verify the behavior of the change.'))
	->setConduitDescription(pht('Update the revision test plan.'))
	->setConduitTypeDescription(pht('New test plan.'))
	->setValue($object->getTestPlan());
	}

	$fields[] = id(new PhabricatorDatasourceEditField())
	->setKey(DifferentialRevisionReviewersTransaction::EDITKEY)
	->setLabel(pht('Reviewers'))
	->setDatasource(new DifferentialReviewerDatasource())
	->setUseEdgeTransactions(true)
	->setTransactionType(
	DifferentialRevisionReviewersTransaction::TRANSACTIONTYPE)
	->setCommentActionLabel(pht('Change Reviewers'))
	->setDescription(pht('Reviewers for this revision.'))
	->setConduitDescription(pht('Change the reviewers for this revision.'))
	->setConduitTypeDescription(pht('New reviewers.'))
	->setValue($object->getReviewerPHIDsForEdit());

	$fields[] = id(new PhabricatorDatasourceEditField())
	->setKey('repositoryPHID')
	->setLabel(pht('Repository'))
	->setDatasource(new DiffusionRepositoryDatasource())
	->setTransactionType(
	DifferentialRevisionRepositoryTransaction::TRANSACTIONTYPE)
	->setDescription(pht('The repository the revision belongs to.'))
	->setConduitDescription(pht('Change the repository for this revision.'))
	->setConduitTypeDescription(pht('New repository.'))
	->setSingleValue($object->getRepositoryPHID());

	// This is a little flimsy, but allows "Maniphest Tasks: ..." to continue
	// working properly in commit messages until we fully sort out T5873.
	$fields[] = id(new PhabricatorHandlesEditField())
	->setKey('tasks')
	->setUseEdgeTransactions(true)
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
	->setMetadataValue(
	'edge:type',
	DifferentialRevisionHasTaskEdgeType::EDGECONST)
	->setDescription(pht('Tasks associated with this revision.'))
	->setConduitDescription(pht('Change associated tasks.'))
	->setConduitTypeDescription(pht('List of tasks.'))
	->setValue(array());

	$actions = DifferentialRevisionActionTransaction::loadAllActions();
	$actions = msortv($actions, 'getRevisionActionOrderVector');

	foreach ($actions as $key => $action) {
	$fields[] = $action->newEditField($object, $viewer);
	}

	$fields[] = id(new PhabricatorBoolEditField())
	->setKey('draft')
	->setLabel(pht('Hold as Draft'))
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setOptions(
	pht('Autosubmit Once Builds Finish'),
	pht('Hold as Draft'))
	->setTransactionType(
	DifferentialRevisionHoldDraftTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Hold revision as as draft.'))
	->setConduitDescription(
	pht(
	'Change autosubmission from draft state after builds finish.'))
	->setConduitTypeDescription(pht('New "Hold as Draft" setting.'))
	->setValue($object->getHoldAsDraft());

	return $fields;
	}

	private function isCustomFieldEnabled(DifferentialRevision $revision, $key) {
	$field_list = PhabricatorCustomField::getObjectFields(
	$revision,
	PhabricatorCustomField::ROLE_VIEW);

	$fields = $field_list->getFields();
	return isset($fields[$key]);
	}

	protected function newAutomaticCommentTransactions($object) {
	$viewer = $this->getViewer();
	$xactions = array();

	$inlines = DifferentialTransactionQuery::loadUnsubmittedInlineComments(
	$viewer,
	$object);
	$inlines = msort($inlines, 'getID');

	foreach ($inlines as $inline) {
	$xactions[] = id(new DifferentialTransaction())
	->setTransactionType(DifferentialTransaction::TYPE_INLINE)
	->attachComment($inline);
	}

	$viewer_phid = $viewer->getPHID();
	$viewer_is_author = ($object->getAuthorPHID() == $viewer_phid);
	if ($viewer_is_author) {
	$state_map = PhabricatorTransactions::getInlineStateMap();

	$inlines = id(new DifferentialDiffInlineCommentQuery())
	->setViewer($viewer)
	->withRevisionPHIDs(array($object->getPHID()))
	->withFixedStates(array_keys($state_map))
	->execute();
	if ($inlines) {
	$old_value = mpull($inlines, 'getFixedState', 'getPHID');
	$new_value = array();
	foreach ($old_value as $key => $state) {
	$new_value[$key] = $state_map[$state];
	}

	$xactions[] = id(new DifferentialTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_INLINESTATE)
	->setIgnoreOnNoEffect(true)
	->setOldValue($old_value)
	->setNewValue($new_value);
	}
	}

	return $xactions;
	}

	protected function newCommentPreviewContent($object, array $xactions) {
	$viewer = $this->getViewer();
	$type_inline = DifferentialTransaction::TYPE_INLINE;

	$inlines = array();
	foreach ($xactions as $xaction) {
	if ($xaction->getTransactionType() === $type_inline) {
	$inlines[] = $xaction->getComment();
	}
	}

	$content = array();

	if ($inlines) {
	$inline_preview = id(new PHUIDiffInlineCommentPreviewListView())
	->setViewer($viewer)
	->setInlineComments($inlines);

	$content[] = phutil_tag(
	'div',
	array(
	'id' => 'inline-comment-preview',
	),
	$inline_preview);
	}

	return $content;
	}


	}
	diff --git a/src/applications/diffusion/editor/DiffusionRepositoryEditEngine.php b/src/applications/diffusion/editor/DiffusionRepositoryEditEngine.php
	index dcb79a6c86..79b97e44be 100644
	--- a/src/applications/diffusion/editor/DiffusionRepositoryEditEngine.php
	+++ b/src/applications/diffusion/editor/DiffusionRepositoryEditEngine.php
	@@ -1,468 +1,468 @@
	<?php

	final class DiffusionRepositoryEditEngine
	extends PhabricatorEditEngine {

	const ENGINECONST = 'diffusion.repository';

	private $versionControlSystem;

	public function setVersionControlSystem($version_control_system) {
	$this->versionControlSystem = $version_control_system;
	return $this;
	}

	public function getVersionControlSystem() {
	return $this->versionControlSystem;
	}

	public function isEngineConfigurable() {
	return false;
	}

	public function isDefaultQuickCreateEngine() {
	return true;
	}

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

	public function getEngineName() {
	return pht('Repositories');
	}

	public function getSummaryHeader() {
	return pht('Edit Repositories');
	}

	public function getSummaryText() {
	return pht('Creates and edits repositories.');
	}

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

	protected function newEditableObject() {
	$viewer = $this->getViewer();
	$repository = PhabricatorRepository::initializeNewRepository($viewer);

	$repository->setDetail('newly-initialized', true);

	$vcs = $this->getVersionControlSystem();
	if ($vcs) {
	$repository->setVersionControlSystem($vcs);
	}

	// Pick a random open service to allocate this repository on, if any exist.
	// If there are no services, we aren't in cluster mode and will allocate
	// locally. If there are services but none permit allocations, we fail.

	// Eventually we can make this more flexible, but this rule is a reasonable
	// starting point as we begin to deploy cluster services.

	$services = id(new AlmanacServiceQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withServiceTypes(
	array(
	AlmanacClusterRepositoryServiceType::SERVICETYPE,
	))
	->needProperties(true)
	->execute();
	if ($services) {
	// Filter out services which do not permit new allocations.
	foreach ($services as $key => $possible_service) {
	if ($possible_service->getAlmanacPropertyValue('closed')) {
	unset($services[$key]);
	}
	}

	if (!$services) {
	throw new Exception(
	pht(
	'This install is configured in cluster mode, but all available '.
	'repository cluster services are closed to new allocations. '.
	'At least one service must be open to allow new allocations to '.
	'take place.'));
	}

	shuffle($services);
	$service = head($services);

	$repository->setAlmanacServicePHID($service->getPHID());
	}

	return $repository;
	}

	protected function newObjectQuery() {
	return new PhabricatorRepositoryQuery();
	}

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

	protected function getObjectCreateButtonText($object) {
	return pht('Create Repository');
	}

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

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

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

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

	protected function getObjectViewURI($object) {
	return $object->getPathURI('manage/');
	}

	protected function getCreateNewObjectPolicy() {
	return $this->getApplication()->getPolicy(
	DiffusionCreateRepositoriesCapability::CAPABILITY);
	}

	protected function newPages($object) {
	$panels = DiffusionRepositoryManagementPanel::getAllPanels();

	$pages = array();
	$uris = array();
	foreach ($panels as $panel_key => $panel) {
	$panel->setRepository($object);

	$uris[$panel_key] = $panel->getPanelURI();

	$page = $panel->newEditEnginePage();
	if (!$page) {
	continue;
	}
	$pages[] = $page;
	}

	$basics_key = DiffusionRepositoryBasicsManagementPanel::PANELKEY;
	$basics_uri = $uris[$basics_key];

	$more_pages = array(
	id(new PhabricatorEditPage())
	->setKey('encoding')
	->setLabel(pht('Text Encoding'))
	->setViewURI($basics_uri)
	->setFieldKeys(
	array(
	'encoding',
	)),
	id(new PhabricatorEditPage())
	->setKey('extensions')
	->setLabel(pht('Extensions'))
	->setIsDefault(true),
	);

	foreach ($more_pages as $page) {
	$pages[] = $page;
	}

	return $pages;
	}

	protected function willConfigureFields($object, array $fields) {
	// Change the default field order so related fields are adjacent.
	$after = array(
	'policy.edit' => array('policy.push'),
	);

	$result = array();
	foreach ($fields as $key => $value) {
	$result[$key] = $value;

	if (!isset($after[$key])) {
	continue;
	}

	foreach ($after[$key] as $next_key) {
	if (!isset($fields[$next_key])) {
	continue;
	}

	unset($result[$next_key]);
	$result[$next_key] = $fields[$next_key];
	unset($fields[$next_key]);
	}
	}

	return $result;
	}


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

	$policies = id(new PhabricatorPolicyQuery())
	->setViewer($viewer)
	->setObject($object)
	->execute();

	$track_value = $object->getDetail('branch-filter', array());
	$track_value = array_keys($track_value);

	$autoclose_value = $object->getDetail('close-commits-filter', array());
	$autoclose_value = array_keys($autoclose_value);

	$automation_instructions = pht(
	"Configure Repository Automation to allow Phabricator to ".
	"write to this repository.".
	"\n\n".
	"IMPORTANT: This feature is new, experimental, and not supported. ".
	"Use it at your own risk.");

	$staging_instructions = pht(
	"To make it easier to run integration tests and builds on code ".
	"under review, you can configure a Staging Area. When `arc` ".
	"creates a diff, it will push a copy of the changes to the ".
	"configured staging area with a corresponding tag.".
	"\n\n".
	"IMPORTANT: This feature is new, experimental, and not supported. ".
	"Use it at your own risk.");

	$subpath_instructions = pht(
	'If you want to import only part of a repository, like `trunk/`, '.
	'you can set a path in Import Only. Phabricator will ignore '.
	'commits which do not affect this path.');

	return array(
	id(new PhabricatorSelectEditField())
	->setKey('vcs')
	->setLabel(pht('Version Control System'))
	->setTransactionType(PhabricatorRepositoryTransaction::TYPE_VCS)
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setIsCopyable(true)
	->setOptions(PhabricatorRepositoryType::getAllRepositoryTypes())
	->setDescription(pht('Underlying repository version control system.'))
	->setConduitDescription(
	pht(
	'Choose which version control system to use when creating a '.
	'repository.'))
	->setConduitTypeDescription(pht('Version control system selection.'))
	->setValue($object->getVersionControlSystem()),
	id(new PhabricatorTextEditField())
	->setKey('name')
	->setLabel(pht('Name'))
	->setIsRequired(true)
	->setTransactionType(PhabricatorRepositoryTransaction::TYPE_NAME)
	->setDescription(pht('The repository name.'))
	->setConduitDescription(pht('Rename the repository.'))
	->setConduitTypeDescription(pht('New repository name.'))
	->setValue($object->getName()),
	id(new PhabricatorTextEditField())
	->setKey('callsign')
	->setLabel(pht('Callsign'))
	->setTransactionType(PhabricatorRepositoryTransaction::TYPE_CALLSIGN)
	->setDescription(pht('The repository callsign.'))
	->setConduitDescription(pht('Change the repository callsign.'))
	->setConduitTypeDescription(pht('New repository callsign.'))
	->setValue($object->getCallsign()),
	id(new PhabricatorTextEditField())
	->setKey('shortName')
	->setLabel(pht('Short Name'))
	->setTransactionType(PhabricatorRepositoryTransaction::TYPE_SLUG)
	->setDescription(pht('Short, unique repository name.'))
	->setConduitDescription(pht('Change the repository short name.'))
	->setConduitTypeDescription(pht('New short name for the repository.'))
	->setValue($object->getRepositorySlug()),
	id(new PhabricatorRemarkupEditField())
	->setKey('description')
	->setLabel(pht('Description'))
	->setTransactionType(PhabricatorRepositoryTransaction::TYPE_DESCRIPTION)
	->setDescription(pht('Repository description.'))
	->setConduitDescription(pht('Change the repository description.'))
	->setConduitTypeDescription(pht('New repository description.'))
	->setValue($object->getDetail('description')),
	id(new PhabricatorTextEditField())
	->setKey('encoding')
	->setLabel(pht('Text Encoding'))
	->setIsCopyable(true)
	->setTransactionType(PhabricatorRepositoryTransaction::TYPE_ENCODING)
	->setDescription(pht('Default text encoding.'))
	->setConduitDescription(pht('Change the default text encoding.'))
	->setConduitTypeDescription(pht('New text encoding.'))
	->setValue($object->getDetail('encoding')),
	id(new PhabricatorBoolEditField())
	->setKey('allowDangerousChanges')
	->setLabel(pht('Allow Dangerous Changes'))
	->setIsCopyable(true)
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setOptions(
	pht('Prevent Dangerous Changes'),
	pht('Allow Dangerous Changes'))
	->setTransactionType(PhabricatorRepositoryTransaction::TYPE_DANGEROUS)
	->setDescription(pht('Permit dangerous changes to be made.'))
	->setConduitDescription(pht('Allow or prevent dangerous changes.'))
	->setConduitTypeDescription(pht('New protection setting.'))
	->setValue($object->shouldAllowDangerousChanges()),
	id(new PhabricatorBoolEditField())
	->setKey('allowEnormousChanges')
	->setLabel(pht('Allow Enormous Changes'))
	->setIsCopyable(true)
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setOptions(
	pht('Prevent Enormous Changes'),
	pht('Allow Enormous Changes'))
	->setTransactionType(PhabricatorRepositoryTransaction::TYPE_ENORMOUS)
	->setDescription(pht('Permit enormous changes to be made.'))
	->setConduitDescription(pht('Allow or prevent enormous changes.'))
	->setConduitTypeDescription(pht('New protection setting.'))
	->setValue($object->shouldAllowEnormousChanges()),
	id(new PhabricatorSelectEditField())
	->setKey('status')
	->setLabel(pht('Status'))
	->setTransactionType(PhabricatorRepositoryTransaction::TYPE_ACTIVATE)
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setOptions(PhabricatorRepository::getStatusNameMap())
	->setDescription(pht('Active or inactive status.'))
	->setConduitDescription(pht('Active or deactivate the repository.'))
	->setConduitTypeDescription(pht('New repository status.'))
	->setValue($object->getStatus()),
	id(new PhabricatorTextEditField())
	->setKey('defaultBranch')
	->setLabel(pht('Default Branch'))
	->setTransactionType(
	PhabricatorRepositoryTransaction::TYPE_DEFAULT_BRANCH)
	->setIsCopyable(true)
	->setDescription(pht('Default branch name.'))
	->setConduitDescription(pht('Set the default branch name.'))
	->setConduitTypeDescription(pht('New default branch name.'))
	->setValue($object->getDetail('default-branch')),
	id(new PhabricatorTextAreaEditField())
	->setIsStringList(true)
	->setKey('trackOnly')
	->setLabel(pht('Track Only'))
	->setTransactionType(
	PhabricatorRepositoryTransaction::TYPE_TRACK_ONLY)
	->setIsCopyable(true)
	->setDescription(pht('Track only these branches.'))
	->setConduitDescription(pht('Set the tracked branches.'))
	->setConduitTypeDescription(pht('New tracked branches.'))
	->setValue($track_value),
	id(new PhabricatorTextAreaEditField())
	->setIsStringList(true)
	->setKey('autocloseOnly')
	->setLabel(pht('Autoclose Only'))
	->setTransactionType(
	PhabricatorRepositoryTransaction::TYPE_AUTOCLOSE_ONLY)
	->setIsCopyable(true)
	->setDescription(pht('Autoclose commits on only these branches.'))
	->setConduitDescription(pht('Set the autoclose branches.'))
	->setConduitTypeDescription(pht('New default tracked branches.'))
	->setValue($autoclose_value),
	id(new PhabricatorTextEditField())
	->setKey('importOnly')
	->setLabel(pht('Import Only'))
	->setTransactionType(
	PhabricatorRepositoryTransaction::TYPE_SVN_SUBPATH)
	->setIsCopyable(true)
	->setDescription(pht('Subpath to selectively import.'))
	->setConduitDescription(pht('Set the subpath to import.'))
	->setConduitTypeDescription(pht('New subpath to import.'))
	->setValue($object->getDetail('svn-subpath'))
	->setControlInstructions($subpath_instructions),
	id(new PhabricatorTextEditField())
	->setKey('stagingAreaURI')
	->setLabel(pht('Staging Area URI'))
	->setTransactionType(
	PhabricatorRepositoryTransaction::TYPE_STAGING_URI)
	->setIsCopyable(true)
	->setDescription(pht('Staging area URI.'))
	->setConduitDescription(pht('Set the staging area URI.'))
	->setConduitTypeDescription(pht('New staging area URI.'))
	->setValue($object->getStagingURI())
	->setControlInstructions($staging_instructions),
	id(new PhabricatorDatasourceEditField())
	->setKey('automationBlueprintPHIDs')
	->setLabel(pht('Use Blueprints'))
	->setTransactionType(
	PhabricatorRepositoryTransaction::TYPE_AUTOMATION_BLUEPRINTS)
	->setIsCopyable(true)
	->setDatasource(new DrydockBlueprintDatasource())
	->setDescription(pht('Automation blueprints.'))
	->setConduitDescription(pht('Change automation blueprints.'))
	->setConduitTypeDescription(pht('New blueprint PHIDs.'))
	->setValue($object->getAutomationBlueprintPHIDs())
	->setControlInstructions($automation_instructions),
	id(new PhabricatorStringListEditField())
	->setKey('symbolLanguages')
	->setLabel(pht('Languages'))
	->setTransactionType(
	PhabricatorRepositoryTransaction::TYPE_SYMBOLS_LANGUAGE)
	->setIsCopyable(true)
	->setDescription(
	pht('Languages which define symbols in this repository.'))
	->setConduitDescription(
	pht('Change symbol languages for this repository.'))
	->setConduitTypeDescription(
	pht('New symbol languages.'))
	->setValue($object->getSymbolLanguages()),
	id(new PhabricatorDatasourceEditField())
	->setKey('symbolRepositoryPHIDs')
	->setLabel(pht('Uses Symbols From'))
	->setTransactionType(
	PhabricatorRepositoryTransaction::TYPE_SYMBOLS_SOURCES)
	->setIsCopyable(true)
	->setDatasource(new DiffusionRepositoryDatasource())
	->setDescription(pht('Repositories to link symbols from.'))
	->setConduitDescription(pht('Change symbol source repositories.'))
	->setConduitTypeDescription(pht('New symbol repositories.'))
	->setValue($object->getSymbolSources()),
	id(new PhabricatorBoolEditField())
	->setKey('publish')
	->setLabel(pht('Publish/Notify'))
	->setTransactionType(
	PhabricatorRepositoryTransaction::TYPE_NOTIFY)
	->setIsCopyable(true)
	->setOptions(
	pht('Disable Notifications, Feed, and Herald'),
	pht('Enable Notifications, Feed, and Herald'))
	->setDescription(pht('Configure how changes are published.'))
	->setConduitDescription(pht('Change publishing options.'))
	->setConduitTypeDescription(pht('New notification setting.'))
	->setValue(!$object->getDetail('herald-disabled')),
	id(new PhabricatorBoolEditField())
	->setKey('autoclose')
	->setLabel(pht('Autoclose'))
	->setTransactionType(
	PhabricatorRepositoryTransaction::TYPE_AUTOCLOSE)
	->setIsCopyable(true)
	->setOptions(
	pht('Disable Autoclose'),
	pht('Enable Autoclose'))
	->setDescription(pht('Stop or resume autoclosing in this repository.'))
	->setConduitDescription(pht('Change autoclose setting.'))
	->setConduitTypeDescription(pht('New autoclose setting.'))
	->setValue(!$object->getDetail('disable-autoclose')),
	id(new PhabricatorPolicyEditField())
	->setKey('policy.push')
	->setLabel(pht('Push Policy'))
	->setAliases(array('push'))
	->setIsCopyable(true)
	->setCapability(DiffusionPushCapability::CAPABILITY)
	->setPolicies($policies)
	->setTransactionType(PhabricatorRepositoryTransaction::TYPE_PUSH_POLICY)
	->setDescription(
	pht('Controls who can push changes to the repository.'))
	->setConduitDescription(
	pht('Change the push policy of the repository.'))
	->setConduitTypeDescription(pht('New policy PHID or constant.'))
	->setValue($object->getPolicy(DiffusionPushCapability::CAPABILITY)),
	);
	}

	}
	diff --git a/src/applications/diffusion/editor/DiffusionURIEditEngine.php b/src/applications/diffusion/editor/DiffusionURIEditEngine.php
	index fdc91cff5f..dbc1238153 100644
	--- a/src/applications/diffusion/editor/DiffusionURIEditEngine.php
	+++ b/src/applications/diffusion/editor/DiffusionURIEditEngine.php
	@@ -1,219 +1,219 @@
	<?php

	final class DiffusionURIEditEngine
	extends PhabricatorEditEngine {

	const ENGINECONST = 'diffusion.uri';

	private $repository;

	public function setRepository(PhabricatorRepository $repository) {
	$this->repository = $repository;
	return $this;
	}

	public function getRepository() {
	return $this->repository;
	}

	public function isEngineConfigurable() {
	return false;
	}

	public function getEngineName() {
	return pht('Repository URIs');
	}

	public function getSummaryHeader() {
	return pht('Edit Repository URI');
	}

	public function getSummaryText() {
	return pht('Creates and edits repository URIs.');
	}

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

	protected function newEditableObject() {
	$uri = PhabricatorRepositoryURI::initializeNewURI();

	$repository = $this->getRepository();
	if ($repository) {
	$uri->setRepositoryPHID($repository->getPHID());
	$uri->attachRepository($repository);
	}

	return $uri;
	}

	protected function newObjectQuery() {
	return new PhabricatorRepositoryURIQuery();
	}

	protected function getObjectCreateTitleText($object) {
	return pht('Create Repository URI');
	}

	protected function getObjectCreateButtonText($object) {
	return pht('Create Repository URI');
	}

	protected function getObjectEditTitleText($object) {
	return pht('Edit Repository URI %d', $object->getID());
	}

	protected function getObjectEditShortText($object) {
	return pht('URI %d', $object->getID());
	}

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

	protected function getObjectName() {
	return pht('Repository URI');
	}

	protected function getObjectViewURI($object) {
	return $object->getViewURI();
	}

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

	$uri_instructions = null;
	if ($object->isBuiltin()) {
	$is_builtin = true;
	$uri_value = (string)$object->getDisplayURI();

	switch ($object->getBuiltinProtocol()) {
	case PhabricatorRepositoryURI::BUILTIN_PROTOCOL_SSH:
	$uri_instructions = pht(
	" - Configure [[ %s \| %s ]] to change the SSH username.\n".
	" - Configure [[ %s \| %s ]] to change the SSH host.\n".
	" - Configure [[ %s \| %s ]] to change the SSH port.",
	'/config/edit/diffusion.ssh-user/',
	'diffusion.ssh-user',
	'/config/edit/diffusion.ssh-host/',
	'diffusion.ssh-host',
	'/config/edit/diffusion.ssh-port/',
	'diffusion.ssh-port');
	break;
	}
	} else {
	$is_builtin = false;
	$uri_value = $object->getURI();

	if ($object->getRepositoryPHID()) {
	$repository = $object->getRepository();
	if ($repository->isGit()) {
	$uri_instructions = pht(
	"Provide the URI of a Git repository. It should usually look ".
	"like one of these examples:\n".
	"\n".
	"\| Example Git URIs\n".
	"\| -----------------------\n".
	"\| `git@github.com:example/example.git`\n".
	"\| `ssh://user@host.com/git/example.git`\n".
	"\| `https://example.com/repository.git`");
	} else if ($repository->isHg()) {
	$uri_instructions = pht(
	"Provide the URI of a Mercurial repository. It should usually ".
	"look like one of these examples:\n".
	"\n".
	"\| Example Mercurial URIs\n".
	"\|-----------------------\n".
	"\| `ssh://hg@bitbucket.org/example/repository`\n".
	"\| `https://bitbucket.org/example/repository`");
	} else if ($repository->isSVN()) {
	$uri_instructions = pht(
	"Provide the Repository Root of a Subversion repository. ".
	"You can identify this by running `svn info` in a working ".
	"copy. It should usually look like one of these examples:\n".
	"\n".
	"\| Example Subversion URIs\n".
	"\|-----------------------\n".
	"\| `http://svn.example.org/svnroot/`\n".
	"\| `svn+ssh://svn.example.com/svnroot/`\n".
	"\| `svn://svn.example.net/svnroot/`\n\n".
	"You MUST specify the root of the repository, not a ".
	"subdirectory.");
	}
	}
	}

	return array(
	id(new PhabricatorHandlesEditField())
	->setKey('repository')
	->setAliases(array('repositoryPHID'))
	->setLabel(pht('Repository'))
	->setIsRequired(true)
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setTransactionType(
	PhabricatorRepositoryURITransaction::TYPE_REPOSITORY)
	->setDescription(pht('The repository this URI is associated with.'))
	->setConduitDescription(
	pht(
	'Create a URI in a given repository. This transaction type '.
	'must be present when creating a new URI and must not be '.
	'present when editing an existing URI.'))
	->setConduitTypeDescription(
	pht('Repository PHID to create a new URI for.'))
	->setSingleValue($object->getRepositoryPHID()),
	id(new PhabricatorTextEditField())
	->setKey('uri')
	->setLabel(pht('URI'))
	->setTransactionType(PhabricatorRepositoryURITransaction::TYPE_URI)
	->setDescription(pht('The repository URI.'))
	->setConduitDescription(pht('Change the repository URI.'))
	->setConduitTypeDescription(pht('New repository URI.'))
	->setIsRequired(!$is_builtin)
	->setIsLocked($is_builtin)
	->setValue($uri_value)
	->setControlInstructions($uri_instructions),
	id(new PhabricatorSelectEditField())
	->setKey('io')
	->setLabel(pht('I/O Type'))
	->setTransactionType(PhabricatorRepositoryURITransaction::TYPE_IO)
	->setDescription(pht('URI I/O behavior.'))
	->setConduitDescription(pht('Adjust I/O behavior.'))
	->setConduitTypeDescription(pht('New I/O behavior.'))
	->setValue($object->getIOType())
	->setOptions($object->getAvailableIOTypeOptions()),
	id(new PhabricatorSelectEditField())
	->setKey('display')
	->setLabel(pht('Display Type'))
	->setTransactionType(PhabricatorRepositoryURITransaction::TYPE_DISPLAY)
	->setDescription(pht('URI display behavior.'))
	->setConduitDescription(pht('Change display behavior.'))
	->setConduitTypeDescription(pht('New display behavior.'))
	->setValue($object->getDisplayType())
	->setOptions($object->getAvailableDisplayTypeOptions()),
	id(new PhabricatorHandlesEditField())
	->setKey('credential')
	->setAliases(array('credentialPHID'))
	->setLabel(pht('Credential'))
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setTransactionType(
	PhabricatorRepositoryURITransaction::TYPE_CREDENTIAL)
	->setDescription(
	pht('The credential to use when interacting with this URI.'))
	->setConduitDescription(pht('Change the credential for this URI.'))
	->setConduitTypeDescription(pht('New credential PHID, or null.'))
	->setSingleValue($object->getCredentialPHID()),
	id(new PhabricatorBoolEditField())
	->setKey('disable')
	->setLabel(pht('Disabled'))
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setTransactionType(PhabricatorRepositoryURITransaction::TYPE_DISABLE)
	->setDescription(pht('Active status of the URI.'))
	->setConduitDescription(pht('Disable or activate the URI.'))
	->setConduitTypeDescription(pht('True to disable the URI.'))
	->setOptions(pht('Enable'), pht('Disable'))
	->setValue($object->getIsDisabled()),
	);
	}

	}
	diff --git a/src/applications/drydock/editor/DrydockBlueprintEditEngine.php b/src/applications/drydock/editor/DrydockBlueprintEditEngine.php
	index 6bd1366ef0..a3b6fdaf75 100644
	--- a/src/applications/drydock/editor/DrydockBlueprintEditEngine.php
	+++ b/src/applications/drydock/editor/DrydockBlueprintEditEngine.php
	@@ -1,173 +1,173 @@
	<?php

	final class DrydockBlueprintEditEngine
	extends PhabricatorEditEngine {

	private $blueprintImplementation;

	const ENGINECONST = 'drydock.blueprint';

	public function isEngineConfigurable() {
	return false;
	}

	public function getEngineName() {
	return pht('Drydock Blueprints');
	}

	public function getSummaryHeader() {
	return pht('Edit Drydock Blueprint Configurations');
	}

	public function getSummaryText() {
	return pht('This engine is used to edit Drydock blueprints.');
	}

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

	public function setBlueprintImplementation(
	DrydockBlueprintImplementation $impl) {
	$this->blueprintImplementation = $impl;
	return $this;
	}

	public function getBlueprintImplementation() {
	return $this->blueprintImplementation;
	}

	protected function newEditableObject() {
	$viewer = $this->getViewer();
	$blueprint = DrydockBlueprint::initializeNewBlueprint($viewer);

	$impl = $this->getBlueprintImplementation();
	if ($impl) {
	$blueprint
	->setClassName(get_class($impl))
	->attachImplementation(clone $impl);
	}

	return $blueprint;
	}

	protected function newEditableObjectFromConduit(array $raw_xactions) {
	$type = null;
	foreach ($raw_xactions as $raw_xaction) {
	if ($raw_xaction['type'] !== 'type') {
	continue;
	}

	$type = $raw_xaction['value'];
	}

	if ($type === null) {
	throw new Exception(
	pht(
	'When creating a new Drydock blueprint via the Conduit API, you '.
	'must provide a "type" transaction to select a type.'));
	}

	$map = DrydockBlueprintImplementation::getAllBlueprintImplementations();
	if (!isset($map[$type])) {
	throw new Exception(
	pht(
	'Blueprint type "%s" is unrecognized. Valid types are: %s.',
	$type,
	implode(', ', array_keys($map))));
	}

	$impl = clone $map[$type];
	$this->setBlueprintImplementation($impl);

	return $this->newEditableObject();
	}

	protected function newEditableObjectForDocumentation() {
	// In order to generate the proper list of fields/transactions for a
	// blueprint, a blueprint's type needs to be known upfront, and there's
	// currently no way to pre-specify the type. Hardcoding an implementation
	// here prevents the fatal on the Conduit API page and allows transactions
	// to be edited.
	$impl = new DrydockWorkingCopyBlueprintImplementation();
	$this->setBlueprintImplementation($impl);
	return $this->newEditableObject();
	}

	protected function newObjectQuery() {
	return new DrydockBlueprintQuery();
	}

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

	protected function getObjectCreateButtonText($object) {
	return pht('Create Blueprint');
	}

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

	protected function getObjectEditShortText($object) {
	return pht('Edit Blueprint');
	}

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

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

	protected function getEditorURI() {
	return '/drydock/blueprint/edit/';
	}

	protected function getObjectCreateCancelURI($object) {
	return '/drydock/blueprint/';
	}

	protected function getObjectViewURI($object) {
	$id = $object->getID();
	return "/drydock/blueprint/{$id}/";
	}

	protected function getCreateNewObjectPolicy() {
	return $this->getApplication()->getPolicy(
	DrydockCreateBlueprintsCapability::CAPABILITY);
	}

	protected function buildCustomEditFields($object) {
	$impl = $object->getImplementation();

	return array(
	// This field appears in the web UI
	id(new PhabricatorStaticEditField())
	->setKey('displayType')
	->setLabel(pht('Blueprint Type'))
	->setDescription(pht('Type of blueprint.'))
	->setValue($impl->getBlueprintName()),
	id(new PhabricatorTextEditField())
	->setKey('type')
	->setLabel(pht('Type'))
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setTransactionType(
	DrydockBlueprintTypeTransaction::TRANSACTIONTYPE)
	->setDescription(pht('When creating a blueprint, set the type.'))
	->setConduitDescription(pht('Set the blueprint type.'))
	->setConduitTypeDescription(pht('Blueprint type.'))
	->setValue($object->getClassName()),
	id(new PhabricatorTextEditField())
	->setKey('name')
	->setLabel(pht('Name'))
	->setDescription(pht('Name of the blueprint.'))
	->setTransactionType(DrydockBlueprintNameTransaction::TRANSACTIONTYPE)
	->setIsRequired(true)
	->setValue($object->getBlueprintName()),
	);
	}

	}
	diff --git a/src/applications/maniphest/editor/ManiphestEditEngine.php b/src/applications/maniphest/editor/ManiphestEditEngine.php
	index c270104034..0b0b4d6758 100644
	--- a/src/applications/maniphest/editor/ManiphestEditEngine.php
	+++ b/src/applications/maniphest/editor/ManiphestEditEngine.php
	@@ -1,529 +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)
	+ ->setIsFormField(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)
	->setIsNullable(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)
	->setBulkEditLabel($action_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)
	+ ->setIsFormField(false)
	->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)
	+ ->setIsFormField(false)
	->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/owners/editor/PhabricatorOwnersPackageEditEngine.php b/src/applications/owners/editor/PhabricatorOwnersPackageEditEngine.php
	index d2eee5685e..044cb8beda 100644
	--- a/src/applications/owners/editor/PhabricatorOwnersPackageEditEngine.php
	+++ b/src/applications/owners/editor/PhabricatorOwnersPackageEditEngine.php
	@@ -1,190 +1,190 @@
	<?php

	final class PhabricatorOwnersPackageEditEngine
	extends PhabricatorEditEngine {

	const ENGINECONST = 'owners.package';

	public function getEngineName() {
	return pht('Owners Packages');
	}

	public function getSummaryHeader() {
	return pht('Configure Owners Package Forms');
	}

	public function getSummaryText() {
	return pht('Configure forms for creating and editing packages in Owners.');
	}

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

	protected function newEditableObject() {
	return PhabricatorOwnersPackage::initializeNewPackage($this->getViewer());
	}

	protected function newObjectQuery() {
	return id(new PhabricatorOwnersPackageQuery())
	->needPaths(true);
	}

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

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

	protected function getObjectEditShortText($object) {
	return pht('Package %d', $object->getID());
	}

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

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

	protected function getObjectViewURI($object) {
	return $object->getURI();
	}

	protected function buildCustomEditFields($object) {

	$paths_help = pht(<<<EOTEXT
	When updating the paths for a package, pass a list of dictionaries like
	this as the `value` for the transaction:

	```lang=json, name="Example Paths Value"
	[
	{
	"repositoryPHID": "PHID-REPO-1234",
	"path": "/path/to/directory/",
	"excluded": false
	},
	{
	"repositoryPHID": "PHID-REPO-1234",
	"path": "/another/example/path/",
	"excluded": false
	}
	]
	```

	This transaction will set the paths to the list you provide, overwriting any
	previous paths.

	Generally, you will call `owners.search` first to get a list of current paths
	(which are provided in the same format), make changes, then update them by
	applying a transaction of this type.
	EOTEXT
	);

	$autoreview_map = PhabricatorOwnersPackage::getAutoreviewOptionsMap();
	$autoreview_map = ipull($autoreview_map, 'name');

	$dominion_map = PhabricatorOwnersPackage::getDominionOptionsMap();
	$dominion_map = ipull($dominion_map, 'name');

	return array(
	id(new PhabricatorTextEditField())
	->setKey('name')
	->setLabel(pht('Name'))
	->setDescription(pht('Name of the package.'))
	->setTransactionType(
	PhabricatorOwnersPackageNameTransaction::TRANSACTIONTYPE)
	->setIsRequired(true)
	->setValue($object->getName()),
	id(new PhabricatorDatasourceEditField())
	->setKey('owners')
	->setLabel(pht('Owners'))
	->setDescription(pht('Users and projects which own the package.'))
	->setTransactionType(
	PhabricatorOwnersPackageOwnersTransaction::TRANSACTIONTYPE)
	->setDatasource(new PhabricatorProjectOrUserDatasource())
	->setIsCopyable(true)
	->setValue($object->getOwnerPHIDs()),
	id(new PhabricatorSelectEditField())
	->setKey('dominion')
	->setLabel(pht('Dominion'))
	->setDescription(
	pht('Change package dominion rules.'))
	->setTransactionType(
	PhabricatorOwnersPackageDominionTransaction::TRANSACTIONTYPE)
	->setIsCopyable(true)
	->setValue($object->getDominion())
	->setOptions($dominion_map),
	id(new PhabricatorSelectEditField())
	->setKey('autoReview')
	->setLabel(pht('Auto Review'))
	->setDescription(
	pht(
	'Automatically trigger reviews for commits affecting files in '.
	'this package.'))
	->setTransactionType(
	PhabricatorOwnersPackageAutoreviewTransaction::TRANSACTIONTYPE)
	->setIsCopyable(true)
	->setValue($object->getAutoReview())
	->setOptions($autoreview_map),
	id(new PhabricatorSelectEditField())
	->setKey('auditing')
	->setLabel(pht('Auditing'))
	->setDescription(
	pht(
	'Automatically trigger audits for commits affecting files in '.
	'this package.'))
	->setTransactionType(
	PhabricatorOwnersPackageAuditingTransaction::TRANSACTIONTYPE)
	->setIsCopyable(true)
	->setValue($object->getAuditingEnabled())
	->setOptions(
	array(
	'' => pht('Disabled'),
	'1' => pht('Enabled'),
	)),
	id(new PhabricatorRemarkupEditField())
	->setKey('description')
	->setLabel(pht('Description'))
	->setDescription(pht('Human-readable description of the package.'))
	->setTransactionType(
	PhabricatorOwnersPackageDescriptionTransaction::TRANSACTIONTYPE)
	->setValue($object->getDescription()),
	id(new PhabricatorSelectEditField())
	->setKey('status')
	->setLabel(pht('Status'))
	->setDescription(pht('Archive or enable the package.'))
	->setTransactionType(
	PhabricatorOwnersPackageStatusTransaction::TRANSACTIONTYPE)
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setValue($object->getStatus())
	->setOptions($object->getStatusNameMap()),
	id(new PhabricatorCheckboxesEditField())
	->setKey('ignored')
	->setLabel(pht('Ignored Attributes'))
	->setDescription(pht('Ignore paths with any of these attributes.'))
	->setTransactionType(
	PhabricatorOwnersPackageIgnoredTransaction::TRANSACTIONTYPE)
	->setValue(array_keys($object->getIgnoredPathAttributes()))
	->setOptions(
	array(
	'generated' => pht('Ignore generated files (review only).'),
	)),
	id(new PhabricatorConduitEditField())
	->setKey('paths.set')
	->setLabel(pht('Paths'))
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setTransactionType(
	PhabricatorOwnersPackagePathsTransaction::TRANSACTIONTYPE)
	->setConduitDescription(
	pht('Overwrite existing package paths with new paths.'))
	->setConduitTypeDescription(
	pht('List of dictionaries, each describing a path.'))
	->setConduitDocumentation($paths_help),
	);
	}

	}
	diff --git a/src/applications/paste/editor/PhabricatorPasteEditEngine.php b/src/applications/paste/editor/PhabricatorPasteEditEngine.php
	index 5578a7c9f6..146565e87e 100644
	--- a/src/applications/paste/editor/PhabricatorPasteEditEngine.php
	+++ b/src/applications/paste/editor/PhabricatorPasteEditEngine.php
	@@ -1,116 +1,116 @@
	<?php

	final class PhabricatorPasteEditEngine
	extends PhabricatorEditEngine {

	const ENGINECONST = 'paste.paste';

	public function getEngineName() {
	return pht('Pastes');
	}

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

	public function getSummaryText() {
	return pht('Configure creation and editing forms in Paste.');
	}

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

	protected function newEditableObject() {
	return PhabricatorPaste::initializeNewPaste($this->getViewer());
	}

	protected function newObjectQuery() {
	return id(new PhabricatorPasteQuery())
	->needRawContent(true);
	}

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

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

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

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

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

	protected function getCommentViewHeaderText($object) {
	return pht('Eat Paste');
	}

	protected function getCommentViewButtonText($object) {
	return pht('Nom Nom Nom Nom Nom');
	}

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

	protected function buildCustomEditFields($object) {
	return array(
	id(new PhabricatorTextEditField())
	->setKey('title')
	->setLabel(pht('Title'))
	->setTransactionType(PhabricatorPasteTitleTransaction::TRANSACTIONTYPE)
	->setDescription(pht('The title of the paste.'))
	->setConduitDescription(pht('Retitle the paste.'))
	->setConduitTypeDescription(pht('New paste title.'))
	->setValue($object->getTitle()),
	id(new PhabricatorDatasourceEditField())
	->setKey('language')
	->setLabel(pht('Language'))
	->setTransactionType(
	PhabricatorPasteLanguageTransaction::TRANSACTIONTYPE)
	->setAliases(array('lang'))
	->setIsCopyable(true)
	->setDatasource(new PasteLanguageSelectDatasource())
	->setDescription(
	pht(
	'Language used for syntax highlighting. By default, inferred '.
	'from the title.'))
	->setConduitDescription(
	pht('Change language used for syntax highlighting.'))
	->setConduitTypeDescription(pht('New highlighting language.'))
	->setSingleValue($object->getLanguage()),
	id(new PhabricatorTextAreaEditField())
	->setKey('text')
	->setLabel(pht('Text'))
	->setTransactionType(
	PhabricatorPasteContentTransaction::TRANSACTIONTYPE)
	->setMonospaced(true)
	->setHeight(AphrontFormTextAreaControl::HEIGHT_VERY_TALL)
	->setDescription(pht('The main body text of the paste.'))
	->setConduitDescription(pht('Change the paste content.'))
	->setConduitTypeDescription(pht('New body content.'))
	->setValue($object->getRawContent()),
	id(new PhabricatorSelectEditField())
	->setKey('status')
	->setLabel(pht('Status'))
	->setTransactionType(
	PhabricatorPasteStatusTransaction::TRANSACTIONTYPE)
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setOptions(PhabricatorPaste::getStatusNameMap())
	->setDescription(pht('Active or archived status.'))
	->setConduitDescription(pht('Active or archive the paste.'))
	->setConduitTypeDescription(pht('New paste status constant.'))
	->setValue($object->getStatus()),
	);
	}

	}
	diff --git a/src/applications/people/editor/PhabricatorUserEditEngine.php b/src/applications/people/editor/PhabricatorUserEditEngine.php
	index c547426b12..c4c1abf1e3 100644
	--- a/src/applications/people/editor/PhabricatorUserEditEngine.php
	+++ b/src/applications/people/editor/PhabricatorUserEditEngine.php
	@@ -1,81 +1,81 @@
	<?php

	final class PhabricatorUserEditEngine
	extends PhabricatorEditEngine {

	const ENGINECONST = 'people.user';

	public function isEngineConfigurable() {
	return false;
	}

	public function getEngineName() {
	return pht('Users');
	}

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

	public function getSummaryText() {
	return pht('Configure creation and editing forms for users.');
	}

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

	protected function newEditableObject() {
	return new PhabricatorUser();
	}

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

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

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

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

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

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

	protected function getObjectViewURI($object) {
	return $object->getURI();
	}

	protected function getCreateNewObjectPolicy() {
	// At least for now, forbid creating new users via EditEngine. This is
	// primarily enforcing that "user.edit" can not create users via the API.
	return PhabricatorPolicies::POLICY_NOONE;
	}

	protected function buildCustomEditFields($object) {
	return array(
	id(new PhabricatorBoolEditField())
	->setKey('disabled')
	->setOptions(pht('Active'), pht('Disabled'))
	->setLabel(pht('Disabled'))
	->setDescription(pht('Disable the user.'))
	->setTransactionType(PhabricatorUserDisableTransaction::TRANSACTIONTYPE)
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setConduitDescription(pht('Disable or enable the user.'))
	->setConduitTypeDescription(pht('True to disable the user.'))
	->setValue($object->getIsDisabled()),
	);
	}

	}
	diff --git a/src/applications/phame/editor/PhameBlogEditEngine.php b/src/applications/phame/editor/PhameBlogEditEngine.php
	index 9b6be308c4..e11dec6847 100644
	--- a/src/applications/phame/editor/PhameBlogEditEngine.php
	+++ b/src/applications/phame/editor/PhameBlogEditEngine.php
	@@ -1,138 +1,138 @@
	<?php

	final class PhameBlogEditEngine
	extends PhabricatorEditEngine {

	const ENGINECONST = 'phame.blog';

	public function getEngineName() {
	return pht('Blogs');
	}

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

	public function getSummaryHeader() {
	return pht('Configure Phame Blog Forms');
	}

	public function getSummaryText() {
	return pht('Configure how blogs in Phame are created and edited.');
	}

	protected function newEditableObject() {
	return PhameBlog::initializeNewBlog($this->getViewer());
	}

	protected function newObjectQuery() {
	return id(new PhameBlogQuery())
	->needProfileImage(true);
	}

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

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

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

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

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

	protected function getObjectCreateCancelURI($object) {
	return $this->getApplication()->getApplicationURI('blog/');
	}

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

	protected function getObjectViewURI($object) {
	return $object->getManageURI();
	}

	protected function getCreateNewObjectPolicy() {
	return $this->getApplication()->getPolicy(
	PhameBlogCreateCapability::CAPABILITY);
	}

	protected function buildCustomEditFields($object) {
	return array(
	id(new PhabricatorTextEditField())
	->setKey('name')
	->setLabel(pht('Name'))
	->setDescription(pht('Blog name.'))
	->setConduitDescription(pht('Retitle the blog.'))
	->setConduitTypeDescription(pht('New blog title.'))
	->setTransactionType(PhameBlogNameTransaction::TRANSACTIONTYPE)
	->setIsRequired(true)
	->setValue($object->getName()),
	id(new PhabricatorTextEditField())
	->setKey('subtitle')
	->setLabel(pht('Subtitle'))
	->setDescription(pht('Blog subtitle.'))
	->setConduitDescription(pht('Change the blog subtitle.'))
	->setConduitTypeDescription(pht('New blog subtitle.'))
	->setTransactionType(PhameBlogSubtitleTransaction::TRANSACTIONTYPE)
	->setValue($object->getSubtitle()),
	id(new PhabricatorRemarkupEditField())
	->setKey('description')
	->setLabel(pht('Description'))
	->setDescription(pht('Blog description.'))
	->setConduitDescription(pht('Change the blog description.'))
	->setConduitTypeDescription(pht('New blog description.'))
	->setTransactionType(PhameBlogDescriptionTransaction::TRANSACTIONTYPE)
	->setValue($object->getDescription()),
	id(new PhabricatorTextEditField())
	->setKey('domainFullURI')
	->setLabel(pht('Full Domain URI'))
	->setControlInstructions(pht('Set Full Domain URI if you plan to '.
	'serve this blog on another hosted domain. Parent Site Name and '.
	'Parent Site URI are optional but helpful since they provide '.
	'a link from the blog back to your parent site.'))
	->setDescription(pht('Blog full domain URI.'))
	->setConduitDescription(pht('Change the blog full domain URI.'))
	->setConduitTypeDescription(pht('New blog full domain URI.'))
	->setValue($object->getDomainFullURI())
	->setTransactionType(PhameBlogFullDomainTransaction::TRANSACTIONTYPE),
	id(new PhabricatorTextEditField())
	->setKey('parentSite')
	->setLabel(pht('Parent Site Name'))
	->setDescription(pht('Blog parent site name.'))
	->setConduitDescription(pht('Change the blog parent site name.'))
	->setConduitTypeDescription(pht('New blog parent site name.'))
	->setValue($object->getParentSite())
	->setTransactionType(PhameBlogParentSiteTransaction::TRANSACTIONTYPE),
	id(new PhabricatorTextEditField())
	->setKey('parentDomain')
	->setLabel(pht('Parent Site URI'))
	->setDescription(pht('Blog parent domain name.'))
	->setConduitDescription(pht('Change the blog parent domain.'))
	->setConduitTypeDescription(pht('New blog parent domain.'))
	->setValue($object->getParentDomain())
	->setTransactionType(PhameBlogParentDomainTransaction::TRANSACTIONTYPE),
	id(new PhabricatorSelectEditField())
	->setKey('status')
	->setLabel(pht('Status'))
	->setTransactionType(PhameBlogStatusTransaction::TRANSACTIONTYPE)
	- ->setIsConduitOnly(true)
	+ ->setIsFormField(false)
	->setOptions(PhameBlog::getStatusNameMap())
	->setDescription(pht('Active or archived status.'))
	->setConduitDescription(pht('Active or archive the blog.'))
	->setConduitTypeDescription(pht('New blog status constant.'))
	->setValue($object->getStatus()),
	);
	}

	}
	diff --git a/src/applications/project/engine/PhabricatorProjectEditEngine.php b/src/applications/project/engine/PhabricatorProjectEditEngine.php
	index 5eb6b49b87..1c84932656 100644
	--- a/src/applications/project/engine/PhabricatorProjectEditEngine.php
	+++ b/src/applications/project/engine/PhabricatorProjectEditEngine.php
	@@ -1,326 +1,326 @@
	<?php

	final class PhabricatorProjectEditEngine
	extends PhabricatorEditEngine {

	const ENGINECONST = 'projects.project';

	private $parentProject;
	private $milestoneProject;

	public function setParentProject(PhabricatorProject $parent_project) {
	$this->parentProject = $parent_project;
	return $this;
	}

	public function getParentProject() {
	return $this->parentProject;
	}

	public function setMilestoneProject(PhabricatorProject $milestone_project) {
	$this->milestoneProject = $milestone_project;
	return $this;
	}

	public function getMilestoneProject() {
	return $this->milestoneProject;
	}

	public function isDefaultQuickCreateEngine() {
	return true;
	}

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

	public function getEngineName() {
	return pht('Projects');
	}

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

	public function getSummaryText() {
	return pht('Configure forms for creating projects.');
	}

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

	protected function newEditableObject() {
	$parent = nonempty($this->parentProject, $this->milestoneProject);

	return PhabricatorProject::initializeNewProject(
	$this->getViewer(),
	$parent);
	}

	protected function newObjectQuery() {
	return id(new PhabricatorProjectQuery())
	->needSlugs(true);
	}

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

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

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

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

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

	protected function getObjectViewURI($object) {
	if ($this->getIsCreate()) {
	return $object->getURI();
	} else {
	$id = $object->getID();
	return "/project/manage/{$id}/";
	}
	}

	protected function getObjectCreateCancelURI($object) {
	$parent = $this->getParentProject();
	$milestone = $this->getMilestoneProject();

	if ($parent \|\| $milestone) {
	$id = nonempty($parent, $milestone)->getID();
	return "/project/subprojects/{$id}/";
	}

	return parent::getObjectCreateCancelURI($object);
	}

	protected function getCreateNewObjectPolicy() {
	return $this->getApplication()->getPolicy(
	ProjectCreateProjectsCapability::CAPABILITY);
	}

	protected function willConfigureFields($object, array $fields) {
	$is_milestone = ($this->getMilestoneProject() \|\| $object->isMilestone());

	$unavailable = array(
	PhabricatorTransactions::TYPE_VIEW_POLICY,
	PhabricatorTransactions::TYPE_EDIT_POLICY,
	PhabricatorTransactions::TYPE_JOIN_POLICY,
	PhabricatorTransactions::TYPE_SPACE,
	PhabricatorProjectIconTransaction::TRANSACTIONTYPE,
	PhabricatorProjectColorTransaction::TRANSACTIONTYPE,
	);
	$unavailable = array_fuse($unavailable);

	if ($is_milestone) {
	foreach ($fields as $key => $field) {
	$xaction_type = $field->getTransactionType();
	if (isset($unavailable[$xaction_type])) {
	unset($fields[$key]);
	}
	}
	}

	return $fields;
	}

	protected function newBuiltinEngineConfigurations() {
	$configuration = head(parent::newBuiltinEngineConfigurations());

	// TODO: This whole method is clumsy, and the ordering for the custom
	// field is especially clumsy. Maybe try to make this more natural to
	// express.

	$configuration
	->setFieldOrder(
	array(
	'parent',
	'milestone',
	'milestone.previous',
	'name',
	'std:project:internal:description',
	'icon',
	'color',
	'slugs',
	));

	return array(
	$configuration,
	);
	}

	protected function buildCustomEditFields($object) {
	$slugs = mpull($object->getSlugs(), 'getSlug');
	$slugs = array_fuse($slugs);
	unset($slugs[$object->getPrimarySlug()]);
	$slugs = array_values($slugs);

	$milestone = $this->getMilestoneProject();
	$parent = $this->getParentProject();

	if ($parent) {
	$parent_phid = $parent->getPHID();
	} else {
	$parent_phid = null;
	}

	$previous_milestone_phid = null;
	if ($milestone) {
	$milestone_phid = $milestone->getPHID();

	// Load the current milestone so we can show the user a hint about what
	// it was called, so they don't have to remember if the next one should
	// be "Sprint 287" or "Sprint 278".

	$number = ($milestone->loadNextMilestoneNumber() - 1);
	if ($number > 0) {
	$previous_milestone = id(new PhabricatorProjectQuery())
	->setViewer($this->getViewer())
	->withParentProjectPHIDs(array($milestone->getPHID()))
	->withIsMilestone(true)
	->withMilestoneNumberBetween($number, $number)
	->executeOne();
	if ($previous_milestone) {
	$previous_milestone_phid = $previous_milestone->getPHID();
	}
	}
	} else {
	$milestone_phid = null;
	}

	$fields = array(
	id(new PhabricatorHandlesEditField())
	->setKey('parent')
	->setLabel(pht('Parent'))
	->setDescription(pht('Create a subproject of an existing project.'))
	->setConduitDescription(
	pht('Choose a parent project to create a subproject beneath.'))
	->setConduitTypeDescription(pht('PHID of the parent project.'))
	->setAliases(array('parentPHID'))
	->setTransactionType(
	PhabricatorProjectParentTransaction::TRANSACTIONTYPE)
	->setHandleParameterType(new AphrontPHIDHTTPParameterType())
	->setSingleValue($parent_phid)
	->setIsReorderable(false)
	->setIsDefaultable(false)
	->setIsLockable(false)
	->setIsLocked(true),
	id(new PhabricatorHandlesEditField())
	->setKey('milestone')
	->setLabel(pht('Milestone Of'))
	->setDescription(pht('Parent project to create a milestone for.'))
	->setConduitDescription(
	pht('Choose a parent project to create a new milestone for.'))
	->setConduitTypeDescription(pht('PHID of the parent project.'))
	->setAliases(array('milestonePHID'))
	->setTransactionType(
	PhabricatorProjectMilestoneTransaction::TRANSACTIONTYPE)
	->setHandleParameterType(new AphrontPHIDHTTPParameterType())
	->setSingleValue($milestone_phid)
	->setIsReorderable(false)
	->setIsDefaultable(false)
	->setIsLockable(false)
	->setIsLocked(true),
	id(new PhabricatorHandlesEditField())
	->setKey('milestone.previous')
	->setLabel(pht('Previous Milestone'))
	->setSingleValue($previous_milestone_phid)
	->setIsReorderable(false)
	->setIsDefaultable(false)
	->setIsLockable(false)
	->setIsLocked(true),
	id(new PhabricatorTextEditField())
	->setKey('name')
	->setLabel(pht('Name'))
	->setTransactionType(PhabricatorProjectNameTransaction::TRANSACTIONTYPE)
	->setIsRequired(true)
	->setDescription(pht('Project name.'))
	->setConduitDescription(pht('Rename the project'))
	->setConduitTypeDescription(pht('New project name.'))
	->setValue($object->getName()),
	id(new PhabricatorIconSetEditField())
	->setKey('icon')
	->setLabel(pht('Icon'))
	->setTransactionType(
	PhabricatorProjectIconTransaction::TRANSACTIONTYPE)
	->setIconSet(new PhabricatorProjectIconSet())
	->setDescription(pht('Project icon.'))
	->setConduitDescription(pht('Change the project icon.'))
	->setConduitTypeDescription(pht('New project icon.'))
	->setValue($object->getIcon()),
	id(new PhabricatorSelectEditField())
	->setKey('color')
	->setLabel(pht('Color'))
	->setTransactionType(
	PhabricatorProjectColorTransaction::TRANSACTIONTYPE)
	->setOptions(PhabricatorProjectIconSet::getColorMap())
	->setDescription(pht('Project tag color.'))
	->setConduitDescription(pht('Change the project tag color.'))
	->setConduitTypeDescription(pht('New project tag color.'))
	->setValue($object->getColor()),
	id(new PhabricatorStringListEditField())
	->setKey('slugs')
	->setLabel(pht('Additional Hashtags'))
	->setTransactionType(
	PhabricatorProjectSlugsTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Additional project slugs.'))
	->setConduitDescription(pht('Change project slugs.'))
	->setConduitTypeDescription(pht('New list of slugs.'))
	->setValue($slugs),
	);

	$can_edit_members = (!$milestone) &&
	(!$object->isMilestone()) &&
	(!$object->getHasSubprojects());

	if ($can_edit_members) {

	// Show this on the web UI when creating a project, but not when editing
	// one. It is always available via Conduit.
	- $conduit_only = !$this->getIsCreate();
	+ $show_field = (bool)$this->getIsCreate();

	$members_field = id(new PhabricatorUsersEditField())
	->setKey('members')
	->setAliases(array('memberPHIDs'))
	->setLabel(pht('Initial Members'))
	- ->setIsConduitOnly($conduit_only)
	+ ->setIsFormField($show_field)
	->setUseEdgeTransactions(true)
	->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
	->setMetadataValue(
	'edge:type',
	PhabricatorProjectProjectHasMemberEdgeType::EDGECONST)
	->setDescription(pht('Initial project members.'))
	->setConduitDescription(pht('Set project members.'))
	->setConduitTypeDescription(pht('New list of members.'))
	->setValue(array());

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

	$edit_add = $members_field->getConduitEditType('members.add')
	->setConduitDescription(pht('Add members.'));

	$edit_set = $members_field->getConduitEditType('members.set')
	->setConduitDescription(
	pht('Set members, overwriting the current value.'));

	$edit_rem = $members_field->getConduitEditType('members.remove')
	->setConduitDescription(pht('Remove members.'));

	$fields[] = $members_field;
	}

	return $fields;

	}

	}
	diff --git a/src/applications/transactions/controller/PhabricatorEditEngineConfigurationDefaultsController.php b/src/applications/transactions/controller/PhabricatorEditEngineConfigurationDefaultsController.php
	index 340431dd19..f7361d50cf 100644
	--- a/src/applications/transactions/controller/PhabricatorEditEngineConfigurationDefaultsController.php
	+++ b/src/applications/transactions/controller/PhabricatorEditEngineConfigurationDefaultsController.php
	@@ -1,123 +1,128 @@
	<?php

	final class PhabricatorEditEngineConfigurationDefaultsController
	extends PhabricatorEditEngineController {

	public function handleRequest(AphrontRequest $request) {
	$engine_key = $request->getURIData('engineKey');
	$this->setEngineKey($engine_key);

	$key = $request->getURIData('key');
	$viewer = $this->getViewer();

	$config = id(new PhabricatorEditEngineConfigurationQuery())
	->setViewer($viewer)
	->withEngineKeys(array($engine_key))
	->withIdentifiers(array($key))
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->executeOne();
	if (!$config) {
	return id(new Aphront404Response());
	}

	$cancel_uri = "/transactions/editengine/{$engine_key}/view/{$key}/";

	$engine = $config->getEngine();
	$fields = $engine->getFieldsForConfig($config);

	foreach ($fields as $key => $field) {
	+ if (!$field->getIsFormField()) {
	+ unset($fields[$key]);
	+ continue;
	+ }
	+
	if (!$field->getIsDefaultable()) {
	unset($fields[$key]);
	continue;
	}
	}

	foreach ($fields as $field) {
	$field->setIsEditDefaults(true);
	}

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

	foreach ($fields as $field) {
	$field->readValueFromSubmit($request);
	}

	$type = PhabricatorEditEngineConfigurationTransaction::TYPE_DEFAULT;

	$xactions = array();
	foreach ($fields as $field) {
	$new_value = $field->getValueForDefaults();
	$xactions[] = id(new PhabricatorEditEngineConfigurationTransaction())
	->setTransactionType($type)
	->setMetadataValue('field.key', $field->getKey())
	->setNewValue($new_value);
	}

	$editor = id(new PhabricatorEditEngineConfigurationEditor())
	->setActor($viewer)
	->setContentSourceFromRequest($request)
	->setContinueOnMissingFields(true)
	->setContinueOnNoEffect(true);

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

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

	$title = pht('Edit Form Defaults');

	$form = id(new AphrontFormView())
	->setUser($viewer);

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

	$form
	->appendControl(
	id(new AphrontFormSubmitControl())
	->setValue(pht('Save Defaults'))
	->addCancelButton($cancel_uri));

	$info = id(new PHUIInfoView())
	->setSeverity(PHUIInfoView::SEVERITY_WARNING)
	->setErrors(
	array(
	pht('You are editing the default values for this form.'),
	));


	$box = id(new PHUIObjectBoxView())
	->setHeaderText(pht('Form'))
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->setForm($form);

	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->addTextCrumb(pht('Form %d', $config->getID()), $cancel_uri);
	$crumbs->addTextCrumb(pht('Edit Defaults'));
	$crumbs->setBorder(true);

	$header = id(new PHUIHeaderView())
	->setHeader(pht('Edit Form Defaults'))
	->setHeaderIcon('fa-pencil');

	$view = id(new PHUITwoColumnView())
	->setHeader($header)
	->setFooter(array(
	$info,
	$box,
	));

	return $this->newPage()
	->setTitle($title)
	->setCrumbs($crumbs)
	->appendChild($view);
	}

	}
	diff --git a/src/applications/transactions/controller/PhabricatorEditEngineConfigurationLockController.php b/src/applications/transactions/controller/PhabricatorEditEngineConfigurationLockController.php
	index 790eaccb47..34b099b9f0 100644
	--- a/src/applications/transactions/controller/PhabricatorEditEngineConfigurationLockController.php
	+++ b/src/applications/transactions/controller/PhabricatorEditEngineConfigurationLockController.php
	@@ -1,117 +1,121 @@
	<?php

	final class PhabricatorEditEngineConfigurationLockController
	extends PhabricatorEditEngineController {

	public function handleRequest(AphrontRequest $request) {
	$engine_key = $request->getURIData('engineKey');
	$this->setEngineKey($engine_key);

	$key = $request->getURIData('key');
	$viewer = $this->getViewer();

	$config = id(new PhabricatorEditEngineConfigurationQuery())
	->setViewer($viewer)
	->withEngineKeys(array($engine_key))
	->withIdentifiers(array($key))
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->executeOne();
	if (!$config) {
	return id(new Aphront404Response());
	}

	$cancel_uri = "/transactions/editengine/{$engine_key}/view/{$key}/";

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

	$locks = $request->getArr('locks');
	$type_locks = PhabricatorEditEngineConfigurationTransaction::TYPE_LOCKS;

	$xactions[] = id(new PhabricatorEditEngineConfigurationTransaction())
	->setTransactionType($type_locks)
	->setNewValue($locks);

	$editor = id(new PhabricatorEditEngineConfigurationEditor())
	->setActor($viewer)
	->setContentSourceFromRequest($request)
	->setContinueOnMissingFields(true)
	->setContinueOnNoEffect(true);

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

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

	$engine = $config->getEngine();
	$fields = $engine->getFieldsForConfig($config);

	$help = pht(<<<EOTEXT
	Locked fields are visible in the form, but their values can not be changed
	by the user.

	Hidden fields are not visible in the form.

	Any assigned default values are still respected, even if the field is locked
	or hidden.
	EOTEXT
	);

	$form = id(new AphrontFormView())
	->setUser($viewer)
	->appendRemarkupInstructions($help);

	$locks = $config->getFieldLocks();

	$lock_visible = PhabricatorEditEngineConfiguration::LOCK_VISIBLE;
	$lock_locked = PhabricatorEditEngineConfiguration::LOCK_LOCKED;
	$lock_hidden = PhabricatorEditEngineConfiguration::LOCK_HIDDEN;

	$map = array(
	$lock_visible => pht('Visible'),
	$lock_locked => pht("\xF0\x9F\x94\x92 Locked"),
	$lock_hidden => pht("\xE2\x9C\x98 Hidden"),
	);

	foreach ($fields as $field) {
	+ if (!$field->getIsFormField()) {
	+ continue;
	+ }
	+
	if (!$field->getIsLockable()) {
	continue;
	}

	$key = $field->getKey();

	$label = $field->getLabel();
	if (!strlen($label)) {
	$label = $key;
	}

	if ($field->getIsHidden()) {
	$value = $lock_hidden;
	} else if ($field->getIsLocked()) {
	$value = $lock_locked;
	} else {
	$value = $lock_visible;
	}

	$form->appendControl(
	id(new AphrontFormSelectControl())
	->setName('locks['.$key.']')
	->setLabel($label)
	->setValue($value)
	->setOptions($map));
	}

	return $this->newDialog()
	->setTitle(pht('Lock / Hide Fields'))
	->setWidth(AphrontDialogView::WIDTH_FORM)
	->appendForm($form)
	->addSubmitButton(pht('Save Changes'))
	->addCancelButton($cancel_uri);
	}

	}
	diff --git a/src/applications/transactions/controller/PhabricatorEditEngineConfigurationReorderController.php b/src/applications/transactions/controller/PhabricatorEditEngineConfigurationReorderController.php
	index 15eb9530fd..6ff36cdfa4 100644
	--- a/src/applications/transactions/controller/PhabricatorEditEngineConfigurationReorderController.php
	+++ b/src/applications/transactions/controller/PhabricatorEditEngineConfigurationReorderController.php
	@@ -1,123 +1,127 @@
	<?php

	final class PhabricatorEditEngineConfigurationReorderController
	extends PhabricatorEditEngineController {

	public function handleRequest(AphrontRequest $request) {
	$engine_key = $request->getURIData('engineKey');
	$this->setEngineKey($engine_key);

	$key = $request->getURIData('key');
	$viewer = $this->getViewer();

	$config = id(new PhabricatorEditEngineConfigurationQuery())
	->setViewer($viewer)
	->withEngineKeys(array($engine_key))
	->withIdentifiers(array($key))
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->executeOne();
	if (!$config) {
	return id(new Aphront404Response());
	}

	$cancel_uri = "/transactions/editengine/{$engine_key}/view/{$key}/";
	$reorder_uri = "/transactions/editengine/{$engine_key}/reorder/{$key}/";

	if ($request->isFormPost()) {
	$xactions = array();
	$key_order = $request->getStrList('keyOrder');

	$type_order = PhabricatorEditEngineConfigurationTransaction::TYPE_ORDER;

	$xactions[] = id(new PhabricatorEditEngineConfigurationTransaction())
	->setTransactionType($type_order)
	->setNewValue($key_order);

	$editor = id(new PhabricatorEditEngineConfigurationEditor())
	->setActor($viewer)
	->setContentSourceFromRequest($request)
	->setContinueOnMissingFields(true)
	->setContinueOnNoEffect(true);

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

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

	$engine = $config->getEngine();
	$fields = $engine->getFieldsForConfig($config);

	$list_id = celerity_generate_unique_node_id();
	$input_id = celerity_generate_unique_node_id();

	$list = id(new PHUIObjectItemListView())
	->setUser($viewer)
	->setID($list_id)
	->setFlush(true);

	$key_order = array();
	foreach ($fields as $field) {
	+ if (!$field->getIsFormField()) {
	+ continue;
	+ }
	+
	if (!$field->getIsReorderable()) {
	continue;
	}

	$label = $field->getLabel();
	$key = $field->getKey();

	if ($label !== null) {
	$header = $label;
	} else {
	$header = $key;
	}

	$item = id(new PHUIObjectItemView())
	->setHeader($header)
	->setGrippable(true)
	->addSigil('editengine-form-field')
	->setMetadata(
	array(
	'fieldKey' => $key,
	));

	$list->addItem($item);

	$key_order[] = $key;
	}

	Javelin::initBehavior(
	'editengine-reorder-fields',
	array(
	'listID' => $list_id,
	'inputID' => $input_id,
	'reorderURI' => $reorder_uri,
	));

	$note = id(new PHUIInfoView())
	->appendChild(pht('Drag and drop fields to reorder them.'))
	->setSeverity(PHUIInfoView::SEVERITY_NOTICE);

	$input = phutil_tag(
	'input',
	array(
	'type' => 'hidden',
	'name' => 'keyOrder',
	'value' => implode(', ', $key_order),
	'id' => $input_id,
	));

	return $this->newDialog()
	->setTitle(pht('Reorder Fields'))
	->setWidth(AphrontDialogView::WIDTH_FORM)
	->appendChild($note)
	->appendChild($list)
	->appendChild($input)
	->addSubmitButton(pht('Save Changes'))
	->addCancelButton($cancel_uri);
	}

	}
	diff --git a/src/applications/transactions/editengine/PhabricatorEditEngine.php b/src/applications/transactions/editengine/PhabricatorEditEngine.php
	index 579b53a989..4e189df164 100644
	--- a/src/applications/transactions/editengine/PhabricatorEditEngine.php
	+++ b/src/applications/transactions/editengine/PhabricatorEditEngine.php
	@@ -1,2618 +1,2622 @@
	<?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);

	$group_key = $field->getBulkEditGroupKey();
	if ($group_key === null) {
	$field->setBulkEditGroupKey('extension');
	}
	}

	$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) {
	+ if (!$field->getIsFormField()) {
	+ continue;
	+ }
	+
	$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;
	}


	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 PHUIDocumentView())
	->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)
	->setRaiseWarnings(!$request->getBool('editEngine.warnings'))
	->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);
	} catch (PhabricatorApplicationTransactionWarningException $ex) {
	return id(new PhabricatorApplicationTransactionWarningResponse())
	->setCancelURI($view_uri)
	->setException($ex);
	}

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

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

	// After T13186, each transaction can individually weaken or replace the
	// capabilities required to apply it, so we no longer need CAN_EDIT to
	// attempt to apply transactions to objects. In practice, almost all
	// transactions require CAN_EDIT so we won't get very far if we don't
	// have it.
	$capabilities = array(
	PhabricatorPolicyCapability::CAN_VIEW,
	);

	$object = $this->newObjectFromIdentifier(
	$identifier,
	$capabilities);
	} 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' => (int)$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);
	}

	$is_strict = $request->getIsStrictlyTyped();

	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 {
	$value = $xaction['value'];
	$value = $parameter_type->getValue($xaction, 'value', $is_strict);
	$value = $type->getTransactionValueFromConduit($value);
	$xaction['value'] = $value;
	} 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) {
	$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 newBulkEditGroupMap() {
	$groups = $this->newBulkEditGroups();

	$map = array();
	foreach ($groups as $group) {
	$key = $group->getKey();

	if (isset($map[$key])) {
	throw new Exception(
	pht(
	'Two bulk edit groups have the same key ("%s"). Each bulk edit '.
	'group must have a unique key.',
	$key));
	}

	$map[$key] = $group;
	}

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

	foreach ($extensions as $extension) {
	$extension_groups = $extension->newBulkEditGroups($this);
	foreach ($extension_groups as $group) {
	$key = $group->getKey();

	if (isset($map[$key])) {
	throw new Exception(
	pht(
	'Extension "%s" defines a bulk edit group with the same key '.
	'("%s") as the main editor or another extension. Each bulk '.
	'edit group must have a unique key.'));
	}

	$map[$key] = $group;
	}
	}

	return $map;
	}

	protected function newBulkEditGroups() {
	return array(
	id(new PhabricatorBulkEditGroup())
	->setKey('default')
	->setLabel(pht('Primary Fields')),
	id(new PhabricatorBulkEditGroup())
	->setKey('extension')
	->setLabel(pht('Support Applications')),
	);
	}

	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);
	$groups = $this->newBulkEditGroupMap();

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

	$group_key = $type->getBulkEditGroupKey();
	if (!$group_key) {
	$group_key = 'default';
	}

	if (!isset($groups[$group_key])) {
	throw new Exception(
	pht(
	'Field "%s" has a bulk edit group key ("%s") with no '.
	'corresponding bulk edit group.',
	$key,
	$group_key));
	}

	$map[] = array(
	'label' => $bulk_label,
	'xaction' => $key,
	'group' => $group_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);
	$template = $object->getApplicationTransactionTemplate();

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

	$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();

	$value = $xaction['value'];
	$value = $edit_type->getTransactionValueFromBulkEdit($value);
	$xaction['value'] = $value;

	$xaction_objects = $edit_type->generateTransactions(
	clone $template,
	$xaction);

	foreach ($xaction_objects as $xaction_object) {
	$raw_xaction = array(
	'type' => $xaction_object->getTransactionType(),
	'metadata' => $xaction_object->getMetadata(),
	'new' => $xaction_object->getNewValue(),
	);

	if ($xaction_object->hasOldValue()) {
	$raw_xaction['old'] = $xaction_object->getOldValue();
	}

	if ($xaction_object->hasComment()) {
	$comment = $xaction_object->getComment();
	$raw_xaction['comment'] = $comment->getContent();
	}

	$raw_xactions[] = $raw_xaction;
	}
	}

	return $raw_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) {
	$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 07bf3589a8..7eafbc60cf 100644
	--- a/src/applications/transactions/editfield/PhabricatorEditField.php
	+++ b/src/applications/transactions/editfield/PhabricatorEditField.php
	@@ -1,920 +1,920 @@
	<?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 $bulkEditGroupKey;

	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 $isFormField = true;

	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 setBulkEditGroupKey($key) {
	$this->bulkEditGroupKey = $key;
	return $this;
	}

	public function getBulkEditGroupKey() {
	return $this->bulkEditGroupKey;
	}

	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;
	+ public function setIsFormField($is_form_field) {
	+ $this->isFormField = $is_form_field;
	return $this;
	}

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

	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() {
	if ($this->getIsHidden()) {
	return null;
	}

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

	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()) {
	+ if (!$this->getIsFormField()) {
	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()) {
	+ if (!$this->getIsFormField()) {
	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() {
	return new PhabricatorSimpleEditType();
	}

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

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

	$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');
	$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');
	$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()) {
	+ if (!$this->getIsFormField()) {
	return false;
	}

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

	return true;
	}

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

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

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

	return true;
	}

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

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

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

	return true;
	}

	public function shouldGenerateTransactionsFromComment() {
	- if ($this->getIsConduitOnly()) {
	+ if (!$this->getCommentActionLabel()) {
	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/engineextension/PhabricatorCommentEditEngineExtension.php b/src/applications/transactions/engineextension/PhabricatorCommentEditEngineExtension.php
	index c5da130b68..0d20533798 100644
	--- a/src/applications/transactions/engineextension/PhabricatorCommentEditEngineExtension.php
	+++ b/src/applications/transactions/engineextension/PhabricatorCommentEditEngineExtension.php
	@@ -1,76 +1,73 @@
	<?php

	final class PhabricatorCommentEditEngineExtension
	extends PhabricatorEditEngineExtension {

	const EXTENSIONKEY = 'transactions.comment';
	const EDITKEY = 'comment';

	public function getExtensionPriority() {
	return 9000;
	}

	public function isExtensionEnabled() {
	return true;
	}

	public function getExtensionName() {
	return pht('Comments');
	}

	public function supportsObject(
	PhabricatorEditEngine $engine,
	PhabricatorApplicationTransactionInterface $object) {

	$xaction = $object->getApplicationTransactionTemplate();

	try {
	$comment = $xaction->getApplicationTransactionCommentObject();
	} catch (PhutilMethodNotImplementedException $ex) {
	$comment = null;
	}

	return (bool)$comment;
	}

	public function newBulkEditGroups(PhabricatorEditEngine $engine) {
	return array(
	id(new PhabricatorBulkEditGroup())
	->setKey('comments')
	->setLabel(pht('Comments')),
	);
	}

	public function buildCustomEditFields(
	PhabricatorEditEngine $engine,
	PhabricatorApplicationTransactionInterface $object) {

	$comment_type = PhabricatorTransactions::TYPE_COMMENT;

	// Comments have a lot of special behavior which doesn't always check
	// this flag, but we set it for consistency.
	$is_interact = true;

	$comment_field = id(new PhabricatorCommentEditField())
	->setKey(self::EDITKEY)
	->setLabel(pht('Comments'))
	->setBulkEditLabel(pht('Add comment'))
	->setBulkEditGroupKey('comments')
	->setAliases(array('comments'))
	- ->setIsHidden(true)
	- ->setIsReorderable(false)
	- ->setIsDefaultable(false)
	- ->setIsLockable(false)
	+ ->setIsFormField(false)
	->setCanApplyWithoutEditCapability($is_interact)
	->setTransactionType($comment_type)
	->setConduitDescription(pht('Make comments.'))
	->setConduitTypeDescription(
	pht('Comment to add, formatted as remarkup.'))
	->setValue(null);

	return array(
	$comment_field,
	);
	}

	}
	diff --git a/src/applications/transactions/engineextension/PhabricatorSubtypeEditEngineExtension.php b/src/applications/transactions/engineextension/PhabricatorSubtypeEditEngineExtension.php
	index 338702478c..7d32545416 100644
	--- a/src/applications/transactions/engineextension/PhabricatorSubtypeEditEngineExtension.php
	+++ b/src/applications/transactions/engineextension/PhabricatorSubtypeEditEngineExtension.php
	@@ -1,60 +1,60 @@
	<?php

	final class PhabricatorSubtypeEditEngineExtension
	extends PhabricatorEditEngineExtension {

	const EXTENSIONKEY = 'editengine.subtype';
	const EDITKEY = 'subtype';

	public function getExtensionPriority() {
	return 8000;
	}

	public function isExtensionEnabled() {
	return true;
	}

	public function getExtensionName() {
	return pht('Subtypes');
	}

	public function supportsObject(
	PhabricatorEditEngine $engine,
	PhabricatorApplicationTransactionInterface $object) {
	return $engine->supportsSubtypes();
	}

	public function buildCustomEditFields(
	PhabricatorEditEngine $engine,
	PhabricatorApplicationTransactionInterface $object) {

	$subtype_type = PhabricatorTransactions::TYPE_SUBTYPE;

	$map = $object->newEditEngineSubtypeMap();
	$options = mpull($map, 'getName');

	$subtype_field = id(new PhabricatorSelectEditField())
	->setKey(self::EDITKEY)
	->setLabel(pht('Subtype'))
	- ->setIsConduitOnly(true)
	- ->setIsHidden(true)
	- ->setIsReorderable(false)
	- ->setIsDefaultable(false)
	- ->setIsLockable(false)
	+ ->setIsFormField(false)
	->setTransactionType($subtype_type)
	->setConduitDescription(pht('Change the object subtype.'))
	->setConduitTypeDescription(pht('New object subtype key.'))
	->setValue($object->getEditEngineSubtype())
	->setOptions($options);

	- // If subtypes are configured, enable changing them from the bulk editor.
	+ // If subtypes are configured, enable changing them from the bulk editor
	+ // and comment action stack.
	if (count($map) > 1) {
	- $subtype_field->setBulkEditLabel(pht('Change subtype to'));
	+ $subtype_field
	+ ->setBulkEditLabel(pht('Change subtype to'))
	+ ->setCommentActionLabel(pht('Change Subtype'))
	+ ->setCommentActionOrder(3000);
	}

	return array(
	$subtype_field,
	);
	}

	}
	diff --git a/src/applications/transactions/storage/PhabricatorEditEngineConfiguration.php b/src/applications/transactions/storage/PhabricatorEditEngineConfiguration.php
	index ada979c45c..3a1c8ec60b 100644
	--- a/src/applications/transactions/storage/PhabricatorEditEngineConfiguration.php
	+++ b/src/applications/transactions/storage/PhabricatorEditEngineConfiguration.php
	@@ -1,351 +1,356 @@
	<?php

	final class PhabricatorEditEngineConfiguration
	extends PhabricatorSearchDAO
	implements
	PhabricatorApplicationTransactionInterface,
	PhabricatorPolicyInterface {

	protected $engineKey;
	protected $builtinKey;
	protected $name;
	protected $viewPolicy;
	protected $properties = array();
	protected $isDisabled = 0;
	protected $isDefault = 0;
	protected $isEdit = 0;
	protected $createOrder = 0;
	protected $editOrder = 0;
	protected $subtype;

	private $engine = self::ATTACHABLE;

	const LOCK_VISIBLE = 'visible';
	const LOCK_LOCKED = 'locked';
	const LOCK_HIDDEN = 'hidden';

	public function getTableName() {
	return 'search_editengineconfiguration';
	}

	public static function initializeNewConfiguration(
	PhabricatorUser $actor,
	PhabricatorEditEngine $engine) {

	return id(new PhabricatorEditEngineConfiguration())
	->setSubtype(PhabricatorEditEngine::SUBTYPE_DEFAULT)
	->setEngineKey($engine->getEngineKey())
	->attachEngine($engine)
	->setViewPolicy(PhabricatorPolicies::getMostOpenPolicy());
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(
	PhabricatorEditEngineConfigurationPHIDType::TYPECONST);
	}

	public function getCreateSortKey() {
	return $this->getSortKey($this->createOrder);
	}

	public function getEditSortKey() {
	return $this->getSortKey($this->editOrder);
	}

	private function getSortKey($order) {
	// Put objects at the bottom by default if they haven't previously been
	// reordered. When they're explicitly reordered, the smallest sort key we
	// assign is 1, so if the object has a value of 0 it means it hasn't been
	// ordered yet.
	if ($order != 0) {
	$group = 'A';
	} else {
	$group = 'B';
	}

	return sprintf(
	"%s%012d%s\0%012d",
	$group,
	$order,
	$this->getName(),
	$this->getID());
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_SERIALIZATION => array(
	'properties' => self::SERIALIZATION_JSON,
	),
	self::CONFIG_COLUMN_SCHEMA => array(
	'engineKey' => 'text64',
	'builtinKey' => 'text64?',
	'name' => 'text255',
	'isDisabled' => 'bool',
	'isDefault' => 'bool',
	'isEdit' => 'bool',
	'createOrder' => 'uint32',
	'editOrder' => 'uint32',
	'subtype' => 'text64',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_engine' => array(
	'columns' => array('engineKey', 'builtinKey'),
	'unique' => true,
	),
	'key_default' => array(
	'columns' => array('engineKey', 'isDefault', 'isDisabled'),
	),
	'key_edit' => array(
	'columns' => array('engineKey', 'isEdit', 'isDisabled'),
	),
	),
	) + parent::getConfiguration();
	}

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

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

	public function setBuiltinKey($key) {
	if (strpos($key, '/') !== false) {
	throw new Exception(
	pht('EditEngine BuiltinKey contains an invalid key character "/".'));
	}
	return parent::setBuiltinKey($key);
	}

	public function attachEngine(PhabricatorEditEngine $engine) {
	$this->engine = $engine;
	return $this;
	}

	public function getEngine() {
	return $this->assertAttached($this->engine);
	}

	public function applyConfigurationToFields(
	PhabricatorEditEngine $engine,
	$object,
	array $fields) {
	$fields = mpull($fields, null, 'getKey');

	$is_new = !$object->getID();

	$values = $this->getProperty('defaults', array());
	foreach ($fields as $key => $field) {
	+ if (!$field->getIsFormField()) {
	+ continue;
	+ }
	+
	if (!$field->getIsDefaultable()) {
	continue;
	}
	+
	if ($is_new) {
	if (array_key_exists($key, $values)) {
	$field->readDefaultValueFromConfiguration($values[$key]);
	}
	}
	}

	$locks = $this->getFieldLocks();
	foreach ($fields as $field) {
	$key = $field->getKey();
	switch (idx($locks, $key)) {
	case self::LOCK_LOCKED:
	$field->setIsHidden(false);
	if ($field->getIsLockable()) {
	$field->setIsLocked(true);
	}
	break;
	case self::LOCK_HIDDEN:
	$field->setIsHidden(true);
	if ($field->getIsLockable()) {
	$field->setIsLocked(false);
	}
	break;
	case self::LOCK_VISIBLE:
	$field->setIsHidden(false);
	if ($field->getIsLockable()) {
	$field->setIsLocked(false);
	}
	break;
	default:
	// If we don't have an explicit value, don't make any adjustments.
	break;
	}
	}

	$fields = $this->reorderFields($fields);

	$preamble = $this->getPreamble();
	if (strlen($preamble)) {
	$fields = array(
	'config.preamble' => id(new PhabricatorInstructionsEditField())
	->setKey('config.preamble')
	->setIsReorderable(false)
	->setIsDefaultable(false)
	->setIsLockable(false)
	->setValue($preamble),
	) + $fields;
	}

	return $fields;
	}

	private function reorderFields(array $fields) {
	// Fields which can not be reordered are fixed in order at the top of the
	// form. These are used to show instructions or contextual information.

	$fixed = array();
	foreach ($fields as $key => $field) {
	if (!$field->getIsReorderable()) {
	$fixed[$key] = $field;
	}
	}

	$keys = $this->getFieldOrder();

	$fields = $fixed + array_select_keys($fields, $keys) + $fields;

	return $fields;
	}

	public function getURI() {
	$engine_key = $this->getEngineKey();
	$key = $this->getIdentifier();

	return "/transactions/editengine/{$engine_key}/view/{$key}/";
	}

	public function getCreateURI() {
	$form_key = $this->getIdentifier();
	$engine = $this->getEngine();

	try {
	$create_uri = $engine->getEditURI(null, "form/{$form_key}/");
	} catch (Exception $ex) {
	$create_uri = null;
	}

	return $create_uri;
	}

	public function getIdentifier() {
	$key = $this->getID();
	if (!$key) {
	$key = $this->getBuiltinKey();
	}
	return $key;
	}

	public function getDisplayName() {
	$name = $this->getName();
	if (strlen($name)) {
	return $name;
	}

	$builtin = $this->getBuiltinKey();
	if ($builtin !== null) {
	return pht('Builtin Form "%s"', $builtin);
	}

	return pht('Untitled Form');
	}

	public function getPreamble() {
	return $this->getProperty('preamble');
	}

	public function setPreamble($preamble) {
	return $this->setProperty('preamble', $preamble);
	}

	public function setFieldOrder(array $field_order) {
	return $this->setProperty('order', $field_order);
	}

	public function getFieldOrder() {
	return $this->getProperty('order', array());
	}

	public function setFieldLocks(array $field_locks) {
	return $this->setProperty('locks', $field_locks);
	}

	public function getFieldLocks() {
	return $this->getProperty('locks', array());
	}

	public function getFieldDefault($key) {
	$defaults = $this->getProperty('defaults', array());
	return idx($defaults, $key);
	}

	public function setFieldDefault($key, $value) {
	$defaults = $this->getProperty('defaults', array());
	$defaults[$key] = $value;
	return $this->setProperty('defaults', $defaults);
	}

	public function getIcon() {
	return $this->getEngine()->getIcon();
	}


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


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

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

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return PhabricatorPolicyFilter::hasCapability(
	$viewer,
	$this->getEngine()->getApplication(),
	PhabricatorPolicyCapability::CAN_EDIT);
	}

	return false;
	}

	/* -( PhabricatorApplicationTransactionInterface )------------------------- */


	public function getApplicationTransactionEditor() {
	return new PhabricatorEditEngineConfigurationEditor();
	}

	public function getApplicationTransactionObject() {
	return $this;
	}

	public function getApplicationTransactionTemplate() {
	return new PhabricatorEditEngineConfigurationTransaction();
	}

	public function willRenderTimeline(
	PhabricatorApplicationTransactionView $timeline,
	AphrontRequest $request) {
	return $timeline;
	}

	}
	diff --git a/src/infrastructure/customfield/editor/PhabricatorCustomFieldEditField.php b/src/infrastructure/customfield/editor/PhabricatorCustomFieldEditField.php
	index 27b8276c85..1a63e040e2 100644
	--- a/src/infrastructure/customfield/editor/PhabricatorCustomFieldEditField.php
	+++ b/src/infrastructure/customfield/editor/PhabricatorCustomFieldEditField.php
	@@ -1,185 +1,185 @@
	<?php

	final class PhabricatorCustomFieldEditField
	extends PhabricatorEditField {

	private $customField;
	private $httpParameterType;
	private $conduitParameterType;
	private $bulkParameterType;
	private $commentAction;

	public function setCustomField(PhabricatorCustomField $custom_field) {
	$this->customField = $custom_field;
	return $this;
	}

	public function getCustomField() {
	return $this->customField;
	}

	public function setCustomFieldHTTPParameterType(
	AphrontHTTPParameterType $type) {
	$this->httpParameterType = $type;
	return $this;
	}

	public function getCustomFieldHTTPParameterType() {
	return $this->httpParameterType;
	}

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

	public function getCustomFieldConduitParameterType() {
	return $this->conduitParameterType;
	}

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

	public function getCustomFieldBulkParameterType() {
	return $this->bulkParameterType;
	}

	public function setCustomFieldCommentAction(
	PhabricatorEditEngineCommentAction $comment_action) {
	$this->commentAction = $comment_action;
	return $this;
	}

	public function getCustomFieldCommentAction() {
	return $this->commentAction;
	}

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

	$field = $this->getCustomField();
	$clone = clone $field;

	$value = $this->getValue();
	$clone->setValueFromApplicationTransactions($value);

	return $clone->renderEditControl(array());
	}

	protected function newEditType() {
	return id(new PhabricatorCustomFieldEditType())
	->setCustomField($this->getCustomField());
	}

	public function getValueForTransaction() {
	$value = $this->getValue();
	$field = $this->getCustomField();

	// Avoid changing the value of the field itself, since later calls would
	// incorrectly reflect the new value.
	$clone = clone $field;
	$clone->setValueFromApplicationTransactions($value);
	return $clone->getNewValueForApplicationTransactions();
	}

	protected function getValueForCommentAction($value) {
	$field = $this->getCustomField();
	$clone = clone $field;
	$clone->setValueFromApplicationTransactions($value);

	// TODO: This is somewhat bogus because only StandardCustomFields
	// implement a getFieldValue() method -- not all CustomFields. Today,
	// only StandardCustomFields can ever actually generate a comment action
	// so we never reach this method with other field types.

	return $clone->getFieldValue();
	}

	protected function getValueExistsInSubmit(AphrontRequest $request, $key) {
	return true;
	}

	protected function getValueFromSubmit(AphrontRequest $request, $key) {
	$field = $this->getCustomField();

	$clone = clone $field;

	$clone->readValueFromRequest($request);
	return $clone->getNewValueForApplicationTransactions();
	}

	protected function newConduitEditTypes() {
	$field = $this->getCustomField();

	if (!$field->shouldAppearInConduitTransactions()) {
	return array();
	}

	return parent::newConduitEditTypes();
	}

	protected function newHTTPParameterType() {
	$type = $this->getCustomFieldHTTPParameterType();

	if ($type) {
	return clone $type;
	}

	return null;
	}

	protected function newCommentAction() {
	$action = $this->getCustomFieldCommentAction();

	if ($action) {
	return clone $action;
	}

	return null;
	}

	protected function newConduitParameterType() {
	$type = $this->getCustomFieldConduitParameterType();

	if ($type) {
	return clone $type;
	}

	return null;
	}

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

	if ($type) {
	return clone $type;
	}

	return null;
	}

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

	// NOTE: This piece of complexity is so we can expose a reasonable key in
	// the UI ("custom.x") instead of a crufty internal key ("std:app:x").
	// Perhaps we can simplify this some day.

	// In the parent, this is just getKey(), but that returns a cumbersome
	// key in EditFields. Use the simpler edit type key instead.
	$keys[] = $this->getEditTypeKey();

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

	return $keys;
	}

	}
	diff --git a/src/infrastructure/customfield/field/PhabricatorCustomField.php b/src/infrastructure/customfield/field/PhabricatorCustomField.php
	index 36db8f239b..d7df3c5b78 100644
	--- a/src/infrastructure/customfield/field/PhabricatorCustomField.php
	+++ b/src/infrastructure/customfield/field/PhabricatorCustomField.php
	@@ -1,1625 +1,1625 @@
	<?php

	/**
	* @task apps Building Applications with Custom Fields
	* @task core Core Properties and Field Identity
	* @task proxy Field Proxies
	* @task context Contextual Data
	* @task render Rendering Utilities
	* @task storage Field Storage
	* @task edit Integration with Edit Views
	* @task view Integration with Property Views
	* @task list Integration with List views
	* @task appsearch Integration with ApplicationSearch
	* @task appxaction Integration with ApplicationTransactions
	* @task xactionmail Integration with Transaction Mail
	* @task globalsearch Integration with Global Search
	* @task herald Integration with Herald
	*/
	abstract class PhabricatorCustomField extends Phobject {

	private $viewer;
	private $object;
	private $proxy;

	const ROLE_APPLICATIONTRANSACTIONS = 'ApplicationTransactions';
	const ROLE_TRANSACTIONMAIL = 'ApplicationTransactions.mail';
	const ROLE_APPLICATIONSEARCH = 'ApplicationSearch';
	const ROLE_STORAGE = 'storage';
	const ROLE_DEFAULT = 'default';
	const ROLE_EDIT = 'edit';
	const ROLE_VIEW = 'view';
	const ROLE_LIST = 'list';
	const ROLE_GLOBALSEARCH = 'GlobalSearch';
	const ROLE_CONDUIT = 'conduit';
	const ROLE_HERALD = 'herald';
	const ROLE_EDITENGINE = 'EditEngine';
	const ROLE_HERALDACTION = 'herald.action';
	const ROLE_EXPORT = 'export';


	/* -( Building Applications with Custom Fields )--------------------------- */


	/**
	* @task apps
	*/
	public static function getObjectFields(
	PhabricatorCustomFieldInterface $object,
	$role) {

	try {
	$attachment = $object->getCustomFields();
	} catch (PhabricatorDataNotAttachedException $ex) {
	$attachment = new PhabricatorCustomFieldAttachment();
	$object->attachCustomFields($attachment);
	}

	try {
	$field_list = $attachment->getCustomFieldList($role);
	} catch (PhabricatorCustomFieldNotAttachedException $ex) {
	$base_class = $object->getCustomFieldBaseClass();

	$spec = $object->getCustomFieldSpecificationForRole($role);
	if (!is_array($spec)) {
	throw new Exception(
	pht(
	"Expected an array from %s for object of class '%s'.",
	'getCustomFieldSpecificationForRole()',
	get_class($object)));
	}

	$fields = self::buildFieldList(
	$base_class,
	$spec,
	$object);

	foreach ($fields as $key => $field) {
	if (!$field->shouldEnableForRole($role)) {
	unset($fields[$key]);
	}
	}

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

	$field_list = new PhabricatorCustomFieldList($fields);
	$attachment->addCustomFieldList($role, $field_list);
	}

	return $field_list;
	}


	/**
	* @task apps
	*/
	public static function getObjectField(
	PhabricatorCustomFieldInterface $object,
	$role,
	$field_key) {

	$fields = self::getObjectFields($object, $role)->getFields();

	return idx($fields, $field_key);
	}


	/**
	* @task apps
	*/
	public static function buildFieldList(
	$base_class,
	array $spec,
	$object,
	array $options = array()) {

	$field_objects = id(new PhutilClassMapQuery())
	->setAncestorClass($base_class)
	->execute();

	$fields = array();
	foreach ($field_objects as $field_object) {
	$field_object = clone $field_object;
	foreach ($field_object->createFields($object) as $field) {
	$key = $field->getFieldKey();
	if (isset($fields[$key])) {
	throw new Exception(
	pht(
	"Both '%s' and '%s' define a custom field with ".
	"field key '%s'. Field keys must be unique.",
	get_class($fields[$key]),
	get_class($field),
	$key));
	}
	$fields[$key] = $field;
	}
	}

	foreach ($fields as $key => $field) {
	if (!$field->isFieldEnabled()) {
	unset($fields[$key]);
	}
	}

	$fields = array_select_keys($fields, array_keys($spec)) + $fields;

	if (empty($options['withDisabled'])) {
	foreach ($fields as $key => $field) {
	if (isset($spec[$key]['disabled'])) {
	$is_disabled = $spec[$key]['disabled'];
	} else {
	$is_disabled = $field->shouldDisableByDefault();
	}

	if ($is_disabled) {
	if ($field->canDisableField()) {
	unset($fields[$key]);
	}
	}
	}
	}

	return $fields;
	}


	/* -( Core Properties and Field Identity )--------------------------------- */


	/**
	* Return a key which uniquely identifies this field, like
	* "mycompany:dinosaur:count". Normally you should provide some level of
	* namespacing to prevent collisions.
	*
	* @return string String which uniquely identifies this field.
	* @task core
	*/
	public function getFieldKey() {
	if ($this->proxy) {
	return $this->proxy->getFieldKey();
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException(
	$this,
	$field_key_is_incomplete = true);
	}

	public function getModernFieldKey() {
	if ($this->proxy) {
	return $this->proxy->getModernFieldKey();
	}
	return $this->getFieldKey();
	}


	/**
	* Return a human-readable field name.
	*
	* @return string Human readable field name.
	* @task core
	*/
	public function getFieldName() {
	if ($this->proxy) {
	return $this->proxy->getFieldName();
	}
	return $this->getModernFieldKey();
	}


	/**
	* Return a short, human-readable description of the field's behavior. This
	* provides more context to administrators when they are customizing fields.
	*
	* @return string\|null Optional human-readable description.
	* @task core
	*/
	public function getFieldDescription() {
	if ($this->proxy) {
	return $this->proxy->getFieldDescription();
	}
	return null;
	}


	/**
	* Most field implementations are unique, in that one class corresponds to
	* one field. However, some field implementations are general and a single
	* implementation may drive several fields.
	*
	* For general implementations, the general field implementation can return
	* multiple field instances here.
	*
	* @param object The object to create fields for.
	* @return list<PhabricatorCustomField> List of fields.
	* @task core
	*/
	public function createFields($object) {
	return array($this);
	}


	/**
	* You can return `false` here if the field should not be enabled for any
	* role. For example, it might depend on something (like an application or
	* library) which isn't installed, or might have some global configuration
	* which allows it to be disabled.
	*
	* @return bool False to completely disable this field for all roles.
	* @task core
	*/
	public function isFieldEnabled() {
	if ($this->proxy) {
	return $this->proxy->isFieldEnabled();
	}
	return true;
	}


	/**
	* Low level selector for field availability. Fields can appear in different
	* roles (like an edit view, a list view, etc.), but not every field needs
	* to appear everywhere. Fields that are disabled in a role won't appear in
	* that context within applications.
	*
	* Normally, you do not need to override this method. Instead, override the
	* methods specific to roles you want to enable. For example, implement
	* @{method:shouldUseStorage()} to activate the `'storage'` role.
	*
	* @return bool True to enable the field for the given role.
	* @task core
	*/
	public function shouldEnableForRole($role) {

	// NOTE: All of these calls proxy individually, so we don't need to
	// proxy this call as a whole.

	switch ($role) {
	case self::ROLE_APPLICATIONTRANSACTIONS:
	return $this->shouldAppearInApplicationTransactions();
	case self::ROLE_APPLICATIONSEARCH:
	return $this->shouldAppearInApplicationSearch();
	case self::ROLE_STORAGE:
	return $this->shouldUseStorage();
	case self::ROLE_EDIT:
	return $this->shouldAppearInEditView();
	case self::ROLE_VIEW:
	return $this->shouldAppearInPropertyView();
	case self::ROLE_LIST:
	return $this->shouldAppearInListView();
	case self::ROLE_GLOBALSEARCH:
	return $this->shouldAppearInGlobalSearch();
	case self::ROLE_CONDUIT:
	return $this->shouldAppearInConduitDictionary();
	case self::ROLE_TRANSACTIONMAIL:
	return $this->shouldAppearInTransactionMail();
	case self::ROLE_HERALD:
	return $this->shouldAppearInHerald();
	case self::ROLE_HERALDACTION:
	return $this->shouldAppearInHeraldActions();
	case self::ROLE_EDITENGINE:
	return $this->shouldAppearInEditView() \|\|
	$this->shouldAppearInEditEngine();
	case self::ROLE_EXPORT:
	return $this->shouldAppearInDataExport();
	case self::ROLE_DEFAULT:
	return true;
	default:
	throw new Exception(pht("Unknown field role '%s'!", $role));
	}
	}


	/**
	* Allow administrators to disable this field. Most fields should allow this,
	* but some are fundamental to the behavior of the application and can be
	* locked down to avoid chaos, disorder, and the decline of civilization.
	*
	* @return bool False to prevent this field from being disabled through
	* configuration.
	* @task core
	*/
	public function canDisableField() {
	return true;
	}

	public function shouldDisableByDefault() {
	return false;
	}


	/**
	* Return an index string which uniquely identifies this field.
	*
	* @return string Index string which uniquely identifies this field.
	* @task core
	*/
	final public function getFieldIndex() {
	return PhabricatorHash::digestForIndex($this->getFieldKey());
	}


	/* -( Field Proxies )------------------------------------------------------ */


	/**
	* Proxies allow a field to use some other field's implementation for most
	* of their behavior while still subclassing an application field. When a
	* proxy is set for a field with @{method:setProxy}, all of its methods will
	* call through to the proxy by default.
	*
	* This is most commonly used to implement configuration-driven custom fields
	* using @{class:PhabricatorStandardCustomField}.
	*
	* This method must be overridden to return `true` before a field can accept
	* proxies.
	*
	* @return bool True if you can @{method:setProxy} this field.
	* @task proxy
	*/
	public function canSetProxy() {
	if ($this instanceof PhabricatorStandardCustomFieldInterface) {
	return true;
	}
	return false;
	}


	/**
	* Set the proxy implementation for this field. See @{method:canSetProxy} for
	* discussion of field proxies.
	*
	* @param PhabricatorCustomField Field implementation.
	* @return this
	*/
	final public function setProxy(PhabricatorCustomField $proxy) {
	if (!$this->canSetProxy()) {
	throw new PhabricatorCustomFieldNotProxyException($this);
	}

	$this->proxy = $proxy;
	return $this;
	}


	/**
	* Get the field's proxy implementation, if any. For discussion, see
	* @{method:canSetProxy}.
	*
	* @return PhabricatorCustomField\|null Proxy field, if one is set.
	*/
	final public function getProxy() {
	return $this->proxy;
	}


	/* -( Contextual Data )---------------------------------------------------- */


	/**
	* Sets the object this field belongs to.
	*
	* @param PhabricatorCustomFieldInterface The object this field belongs to.
	* @return this
	* @task context
	*/
	final public function setObject(PhabricatorCustomFieldInterface $object) {
	if ($this->proxy) {
	$this->proxy->setObject($object);
	return $this;
	}

	$this->object = $object;
	$this->didSetObject($object);
	return $this;
	}


	/**
	* Read object data into local field storage, if applicable.
	*
	* @param PhabricatorCustomFieldInterface The object this field belongs to.
	* @return this
	* @task context
	*/
	public function readValueFromObject(PhabricatorCustomFieldInterface $object) {
	if ($this->proxy) {
	$this->proxy->readValueFromObject($object);
	}
	return $this;
	}


	/**
	* Get the object this field belongs to.
	*
	* @return PhabricatorCustomFieldInterface The object this field belongs to.
	* @task context
	*/
	final public function getObject() {
	if ($this->proxy) {
	return $this->proxy->getObject();
	}

	return $this->object;
	}


	/**
	* This is a hook, primarily for subclasses to load object data.
	*
	* @return PhabricatorCustomFieldInterface The object this field belongs to.
	* @return void
	*/
	protected function didSetObject(PhabricatorCustomFieldInterface $object) {
	return;
	}


	/**
	* @task context
	*/
	final public function setViewer(PhabricatorUser $viewer) {
	if ($this->proxy) {
	$this->proxy->setViewer($viewer);
	return $this;
	}

	$this->viewer = $viewer;
	return $this;
	}


	/**
	* @task context
	*/
	final public function getViewer() {
	if ($this->proxy) {
	return $this->proxy->getViewer();
	}

	return $this->viewer;
	}


	/**
	* @task context
	*/
	final protected function requireViewer() {
	if ($this->proxy) {
	return $this->proxy->requireViewer();
	}

	if (!$this->viewer) {
	throw new PhabricatorCustomFieldDataNotAvailableException($this);
	}
	return $this->viewer;
	}


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


	/**
	* @task render
	*/
	protected function renderHandleList(array $handles) {
	if (!$handles) {
	return null;
	}

	$out = array();
	foreach ($handles as $handle) {
	$out[] = $handle->renderHovercardLink();
	}

	return phutil_implode_html(phutil_tag('br'), $out);
	}


	/* -( Storage )------------------------------------------------------------ */


	/**
	* Return true to use field storage.
	*
	* Fields which can be edited by the user will most commonly use storage,
	* while some other types of fields (for instance, those which just display
	* information in some stylized way) may not. Many builtin fields do not use
	* storage because their data is available on the object itself.
	*
	* If you implement this, you must also implement @{method:getValueForStorage}
	* and @{method:setValueFromStorage}.
	*
	* @return bool True to use storage.
	* @task storage
	*/
	public function shouldUseStorage() {
	if ($this->proxy) {
	return $this->proxy->shouldUseStorage();
	}
	return false;
	}


	/**
	* Return a new, empty storage object. This should be a subclass of
	* @{class:PhabricatorCustomFieldStorage} which is bound to the application's
	* database.
	*
	* @return PhabricatorCustomFieldStorage New empty storage object.
	* @task storage
	*/
	public function newStorageObject() {
	// NOTE: This intentionally isn't proxied, to avoid call cycles.
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* Return a serialized representation of the field value, appropriate for
	* storing in auxiliary field storage. You must implement this method if
	* you implement @{method:shouldUseStorage}.
	*
	* If the field value is a scalar, it can be returned unmodiifed. If not,
	* it should be serialized (for example, using JSON).
	*
	* @return string Serialized field value.
	* @task storage
	*/
	public function getValueForStorage() {
	if ($this->proxy) {
	return $this->proxy->getValueForStorage();
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* Set the field's value given a serialized storage value. This is called
	* when the field is loaded; if no data is available, the value will be
	* null. You must implement this method if you implement
	* @{method:shouldUseStorage}.
	*
	* Usually, the value can be loaded directly. If it isn't a scalar, you'll
	* need to undo whatever serialization you applied in
	* @{method:getValueForStorage}.
	*
	* @param string\|null Serialized field representation (from
	* @{method:getValueForStorage}) or null if no value has
	* ever been stored.
	* @return this
	* @task storage
	*/
	public function setValueFromStorage($value) {
	if ($this->proxy) {
	return $this->proxy->setValueFromStorage($value);
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}

	public function didSetValueFromStorage() {
	if ($this->proxy) {
	return $this->proxy->didSetValueFromStorage();
	}
	return $this;
	}


	/* -( ApplicationSearch )-------------------------------------------------- */


	/**
	* Appearing in ApplicationSearch allows a field to be indexed and searched
	* for.
	*
	* @return bool True to appear in ApplicationSearch.
	* @task appsearch
	*/
	public function shouldAppearInApplicationSearch() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInApplicationSearch();
	}
	return false;
	}


	/**
	* Return one or more indexes which this field can meaningfully query against
	* to implement ApplicationSearch.
	*
	* Normally, you should build these using @{method:newStringIndex} and
	* @{method:newNumericIndex}. For example, if a field holds a numeric value
	* it might return a single numeric index:
	*
	* return array($this->newNumericIndex($this->getValue()));
	*
	* If a field holds a more complex value (like a list of users), it might
	* return several string indexes:
	*
	* $indexes = array();
	* foreach ($this->getValue() as $phid) {
	* $indexes[] = $this->newStringIndex($phid);
	* }
	* return $indexes;
	*
	* @return list<PhabricatorCustomFieldIndexStorage> List of indexes.
	* @task appsearch
	*/
	public function buildFieldIndexes() {
	if ($this->proxy) {
	return $this->proxy->buildFieldIndexes();
	}
	return array();
	}


	/**
	* Return an index against which this field can be meaningfully ordered
	* against to implement ApplicationSearch.
	*
	* This should be a single index, normally built using
	* @{method:newStringIndex} and @{method:newNumericIndex}.
	*
	* The value of the index is not used.
	*
	* Return null from this method if the field can not be ordered.
	*
	* @return PhabricatorCustomFieldIndexStorage A single index to order by.
	* @task appsearch
	*/
	public function buildOrderIndex() {
	if ($this->proxy) {
	return $this->proxy->buildOrderIndex();
	}
	return null;
	}


	/**
	* Build a new empty storage object for storing string indexes. Normally,
	* this should be a concrete subclass of
	* @{class:PhabricatorCustomFieldStringIndexStorage}.
	*
	* @return PhabricatorCustomFieldStringIndexStorage Storage object.
	* @task appsearch
	*/
	protected function newStringIndexStorage() {
	// NOTE: This intentionally isn't proxied, to avoid call cycles.
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* Build a new empty storage object for storing string indexes. Normally,
	* this should be a concrete subclass of
	* @{class:PhabricatorCustomFieldStringIndexStorage}.
	*
	* @return PhabricatorCustomFieldStringIndexStorage Storage object.
	* @task appsearch
	*/
	protected function newNumericIndexStorage() {
	// NOTE: This intentionally isn't proxied, to avoid call cycles.
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* Build and populate storage for a string index.
	*
	* @param string String to index.
	* @return PhabricatorCustomFieldStringIndexStorage Populated storage.
	* @task appsearch
	*/
	protected function newStringIndex($value) {
	if ($this->proxy) {
	return $this->proxy->newStringIndex();
	}

	$key = $this->getFieldIndex();
	return $this->newStringIndexStorage()
	->setIndexKey($key)
	->setIndexValue($value);
	}


	/**
	* Build and populate storage for a numeric index.
	*
	* @param string Numeric value to index.
	* @return PhabricatorCustomFieldNumericIndexStorage Populated storage.
	* @task appsearch
	*/
	protected function newNumericIndex($value) {
	if ($this->proxy) {
	return $this->proxy->newNumericIndex();
	}
	$key = $this->getFieldIndex();
	return $this->newNumericIndexStorage()
	->setIndexKey($key)
	->setIndexValue($value);
	}


	/**
	* Read a query value from a request, for storage in a saved query. Normally,
	* this method should, e.g., read a string out of the request.
	*
	* @param PhabricatorApplicationSearchEngine Engine building the query.
	* @param AphrontRequest Request to read from.
	* @return wild
	* @task appsearch
	*/
	public function readApplicationSearchValueFromRequest(
	PhabricatorApplicationSearchEngine $engine,
	AphrontRequest $request) {
	if ($this->proxy) {
	return $this->proxy->readApplicationSearchValueFromRequest(
	$engine,
	$request);
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* Constrain a query, given a field value. Generally, this method should
	* use `with...()` methods to apply filters or other constraints to the
	* query.
	*
	* @param PhabricatorApplicationSearchEngine Engine executing the query.
	* @param PhabricatorCursorPagedPolicyAwareQuery Query to constrain.
	* @param wild Constraint provided by the user.
	* @return void
	* @task appsearch
	*/
	public function applyApplicationSearchConstraintToQuery(
	PhabricatorApplicationSearchEngine $engine,
	PhabricatorCursorPagedPolicyAwareQuery $query,
	$value) {
	if ($this->proxy) {
	return $this->proxy->applyApplicationSearchConstraintToQuery(
	$engine,
	$query,
	$value);
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* Append search controls to the interface.
	*
	* @param PhabricatorApplicationSearchEngine Engine constructing the form.
	* @param AphrontFormView The form to update.
	* @param wild Value from the saved query.
	* @return void
	* @task appsearch
	*/
	public function appendToApplicationSearchForm(
	PhabricatorApplicationSearchEngine $engine,
	AphrontFormView $form,
	$value) {
	if ($this->proxy) {
	return $this->proxy->appendToApplicationSearchForm(
	$engine,
	$form,
	$value);
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/* -( ApplicationTransactions )-------------------------------------------- */


	/**
	* Appearing in ApplicationTrasactions allows a field to be edited using
	* standard workflows.
	*
	* @return bool True to appear in ApplicationTransactions.
	* @task appxaction
	*/
	public function shouldAppearInApplicationTransactions() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInApplicationTransactions();
	}
	return false;
	}


	/**
	* @task appxaction
	*/
	public function getApplicationTransactionType() {
	if ($this->proxy) {
	return $this->proxy->getApplicationTransactionType();
	}
	return PhabricatorTransactions::TYPE_CUSTOMFIELD;
	}


	/**
	* @task appxaction
	*/
	public function getApplicationTransactionMetadata() {
	if ($this->proxy) {
	return $this->proxy->getApplicationTransactionMetadata();
	}
	return array();
	}


	/**
	* @task appxaction
	*/
	public function getOldValueForApplicationTransactions() {
	if ($this->proxy) {
	return $this->proxy->getOldValueForApplicationTransactions();
	}
	return $this->getValueForStorage();
	}


	/**
	* @task appxaction
	*/
	public function getNewValueForApplicationTransactions() {
	if ($this->proxy) {
	return $this->proxy->getNewValueForApplicationTransactions();
	}
	return $this->getValueForStorage();
	}


	/**
	* @task appxaction
	*/
	public function setValueFromApplicationTransactions($value) {
	if ($this->proxy) {
	return $this->proxy->setValueFromApplicationTransactions($value);
	}
	return $this->setValueFromStorage($value);
	}


	/**
	* @task appxaction
	*/
	public function getNewValueFromApplicationTransactions(
	PhabricatorApplicationTransaction $xaction) {
	if ($this->proxy) {
	return $this->proxy->getNewValueFromApplicationTransactions($xaction);
	}
	return $xaction->getNewValue();
	}


	/**
	* @task appxaction
	*/
	public function getApplicationTransactionHasEffect(
	PhabricatorApplicationTransaction $xaction) {
	if ($this->proxy) {
	return $this->proxy->getApplicationTransactionHasEffect($xaction);
	}
	return ($xaction->getOldValue() !== $xaction->getNewValue());
	}


	/**
	* @task appxaction
	*/
	public function applyApplicationTransactionInternalEffects(
	PhabricatorApplicationTransaction $xaction) {
	if ($this->proxy) {
	return $this->proxy->applyApplicationTransactionInternalEffects($xaction);
	}
	return;
	}


	/**
	* @task appxaction
	*/
	public function getApplicationTransactionRemarkupBlocks(
	PhabricatorApplicationTransaction $xaction) {
	if ($this->proxy) {
	return $this->proxy->getApplicationTransactionRemarkupBlocks($xaction);
	}
	return array();
	}


	/**
	* @task appxaction
	*/
	public function applyApplicationTransactionExternalEffects(
	PhabricatorApplicationTransaction $xaction) {
	if ($this->proxy) {
	return $this->proxy->applyApplicationTransactionExternalEffects($xaction);
	}

	if (!$this->shouldEnableForRole(self::ROLE_STORAGE)) {
	return;
	}

	$this->setValueFromApplicationTransactions($xaction->getNewValue());
	$value = $this->getValueForStorage();

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

	if ($value === null) {
	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE objectPHID = %s AND fieldIndex = %s',
	$table->getTableName(),
	$this->getObject()->getPHID(),
	$this->getFieldIndex());
	} else {
	queryfx(
	$conn_w,
	'INSERT INTO %T (objectPHID, fieldIndex, fieldValue)
	VALUES (%s, %s, %s)
	ON DUPLICATE KEY UPDATE fieldValue = VALUES(fieldValue)',
	$table->getTableName(),
	$this->getObject()->getPHID(),
	$this->getFieldIndex(),
	$value);
	}

	return;
	}


	/**
	* Validate transactions for an object. This allows you to raise an error
	* when a transaction would set a field to an invalid value, or when a field
	* is required but no transactions provide value.
	*
	* @param PhabricatorLiskDAO Editor applying the transactions.
	* @param string Transaction type. This type is always
	* `PhabricatorTransactions::TYPE_CUSTOMFIELD`, it is provided for
	* convenience when constructing exceptions.
	* @param list<PhabricatorApplicationTransaction> Transactions being applied,
	* which may be empty if this field is not being edited.
	* @return list<PhabricatorApplicationTransactionValidationError> Validation
	* errors.
	*
	* @task appxaction
	*/
	public function validateApplicationTransactions(
	PhabricatorApplicationTransactionEditor $editor,
	$type,
	array $xactions) {
	if ($this->proxy) {
	return $this->proxy->validateApplicationTransactions(
	$editor,
	$type,
	$xactions);
	}
	return array();
	}

	public function getApplicationTransactionTitle(
	PhabricatorApplicationTransaction $xaction) {
	if ($this->proxy) {
	return $this->proxy->getApplicationTransactionTitle(
	$xaction);
	}

	$author_phid = $xaction->getAuthorPHID();
	return pht(
	'%s updated this object.',
	$xaction->renderHandleLink($author_phid));
	}

	public function getApplicationTransactionTitleForFeed(
	PhabricatorApplicationTransaction $xaction) {
	if ($this->proxy) {
	return $this->proxy->getApplicationTransactionTitleForFeed(
	$xaction);
	}

	$author_phid = $xaction->getAuthorPHID();
	$object_phid = $xaction->getObjectPHID();
	return pht(
	'%s updated %s.',
	$xaction->renderHandleLink($author_phid),
	$xaction->renderHandleLink($object_phid));
	}


	public function getApplicationTransactionHasChangeDetails(
	PhabricatorApplicationTransaction $xaction) {
	if ($this->proxy) {
	return $this->proxy->getApplicationTransactionHasChangeDetails(
	$xaction);
	}
	return false;
	}

	public function getApplicationTransactionChangeDetails(
	PhabricatorApplicationTransaction $xaction,
	PhabricatorUser $viewer) {
	if ($this->proxy) {
	return $this->proxy->getApplicationTransactionChangeDetails(
	$xaction,
	$viewer);
	}
	return null;
	}

	public function getApplicationTransactionRequiredHandlePHIDs(
	PhabricatorApplicationTransaction $xaction) {
	if ($this->proxy) {
	return $this->proxy->getApplicationTransactionRequiredHandlePHIDs(
	$xaction);
	}
	return array();
	}

	public function shouldHideInApplicationTransactions(
	PhabricatorApplicationTransaction $xaction) {
	if ($this->proxy) {
	return $this->proxy->shouldHideInApplicationTransactions($xaction);
	}
	return false;
	}


	/* -( Transaction Mail )--------------------------------------------------- */


	/**
	* @task xactionmail
	*/
	public function shouldAppearInTransactionMail() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInTransactionMail();
	}
	return false;
	}


	/**
	* @task xactionmail
	*/
	public function updateTransactionMailBody(
	PhabricatorMetaMTAMailBody $body,
	PhabricatorApplicationTransactionEditor $editor,
	array $xactions) {
	if ($this->proxy) {
	return $this->proxy->updateTransactionMailBody($body, $editor, $xactions);
	}
	return;
	}


	/* -( Edit View )---------------------------------------------------------- */


	public function getEditEngineFields(PhabricatorEditEngine $engine) {
	$field = $this->newStandardEditField();

	return array(
	$field,
	);
	}

	protected function newEditField() {
	$field = id(new PhabricatorCustomFieldEditField())
	->setCustomField($this);

	$http_type = $this->getHTTPParameterType();
	if ($http_type) {
	$field->setCustomFieldHTTPParameterType($http_type);
	}

	$conduit_type = $this->getConduitEditParameterType();
	if ($conduit_type) {
	$field->setCustomFieldConduitParameterType($conduit_type);
	}

	$bulk_type = $this->getBulkParameterType();
	if ($bulk_type) {
	$field->setCustomFieldBulkParameterType($bulk_type);
	}

	$comment_action = $this->getCommentAction();
	if ($comment_action) {
	$field
	->setCustomFieldCommentAction($comment_action)
	->setCommentActionLabel(
	pht(
	'Change %s',
	$this->getFieldName()));
	}

	return $field;
	}

	protected function newStandardEditField() {
	if ($this->proxy) {
	return $this->proxy->newStandardEditField();
	}

	- if (!$this->shouldAppearInEditView()) {
	- $conduit_only = true;
	+ if ($this->shouldAppearInEditView()) {
	+ $form_field = true;
	} else {
	- $conduit_only = false;
	+ $form_field = false;
	}

	$bulk_label = $this->getBulkEditLabel();

	return $this->newEditField()
	->setKey($this->getFieldKey())
	->setEditTypeKey($this->getModernFieldKey())
	->setLabel($this->getFieldName())
	->setBulkEditLabel($bulk_label)
	->setDescription($this->getFieldDescription())
	->setTransactionType($this->getApplicationTransactionType())
	- ->setIsConduitOnly($conduit_only)
	+ ->setIsFormField($form_field)
	->setValue($this->getNewValueForApplicationTransactions());
	}

	protected function getBulkEditLabel() {
	if ($this->proxy) {
	return $this->proxy->getBulkEditLabel();
	}

	return pht('Set "%s" to', $this->getFieldName());
	}

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

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

	protected function getHTTPParameterType() {
	if ($this->proxy) {
	return $this->proxy->getHTTPParameterType();
	}
	return null;
	}

	/**
	* @task edit
	*/
	public function shouldAppearInEditView() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInEditView();
	}
	return false;
	}

	/**
	* @task edit
	*/
	public function shouldAppearInEditEngine() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInEditEngine();
	}
	return false;
	}


	/**
	* @task edit
	*/
	public function readValueFromRequest(AphrontRequest $request) {
	if ($this->proxy) {
	return $this->proxy->readValueFromRequest($request);
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* @task edit
	*/
	public function getRequiredHandlePHIDsForEdit() {
	if ($this->proxy) {
	return $this->proxy->getRequiredHandlePHIDsForEdit();
	}
	return array();
	}


	/**
	* @task edit
	*/
	public function getInstructionsForEdit() {
	if ($this->proxy) {
	return $this->proxy->getInstructionsForEdit();
	}
	return null;
	}


	/**
	* @task edit
	*/
	public function renderEditControl(array $handles) {
	if ($this->proxy) {
	return $this->proxy->renderEditControl($handles);
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/* -( Property View )------------------------------------------------------ */


	/**
	* @task view
	*/
	public function shouldAppearInPropertyView() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInPropertyView();
	}
	return false;
	}


	/**
	* @task view
	*/
	public function renderPropertyViewLabel() {
	if ($this->proxy) {
	return $this->proxy->renderPropertyViewLabel();
	}
	return $this->getFieldName();
	}


	/**
	* @task view
	*/
	public function renderPropertyViewValue(array $handles) {
	if ($this->proxy) {
	return $this->proxy->renderPropertyViewValue($handles);
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* @task view
	*/
	public function getStyleForPropertyView() {
	if ($this->proxy) {
	return $this->proxy->getStyleForPropertyView();
	}
	return 'property';
	}


	/**
	* @task view
	*/
	public function getIconForPropertyView() {
	if ($this->proxy) {
	return $this->proxy->getIconForPropertyView();
	}
	return null;
	}


	/**
	* @task view
	*/
	public function getRequiredHandlePHIDsForPropertyView() {
	if ($this->proxy) {
	return $this->proxy->getRequiredHandlePHIDsForPropertyView();
	}
	return array();
	}


	/* -( List View )---------------------------------------------------------- */


	/**
	* @task list
	*/
	public function shouldAppearInListView() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInListView();
	}
	return false;
	}


	/**
	* @task list
	*/
	public function renderOnListItem(PHUIObjectItemView $view) {
	if ($this->proxy) {
	return $this->proxy->renderOnListItem($view);
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/* -( Global Search )------------------------------------------------------ */


	/**
	* @task globalsearch
	*/
	public function shouldAppearInGlobalSearch() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInGlobalSearch();
	}
	return false;
	}


	/**
	* @task globalsearch
	*/
	public function updateAbstractDocument(
	PhabricatorSearchAbstractDocument $document) {
	if ($this->proxy) {
	return $this->proxy->updateAbstractDocument($document);
	}
	return $document;
	}


	/* -( Data Export )-------------------------------------------------------- */


	public function shouldAppearInDataExport() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInDataExport();
	}

	try {
	$this->newExportFieldType();
	return true;
	} catch (PhabricatorCustomFieldImplementationIncompleteException $ex) {
	return false;
	}
	}

	public function newExportField() {
	if ($this->proxy) {
	return $this->proxy->newExportField();
	}

	return $this->newExportFieldType()
	->setLabel($this->getFieldName());
	}

	public function newExportData() {
	if ($this->proxy) {
	return $this->proxy->newExportData();
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}

	protected function newExportFieldType() {
	if ($this->proxy) {
	return $this->proxy->newExportFieldType();
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


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


	/**
	* @task conduit
	*/
	public function shouldAppearInConduitDictionary() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInConduitDictionary();
	}
	return false;
	}


	/**
	* @task conduit
	*/
	public function getConduitDictionaryValue() {
	if ($this->proxy) {
	return $this->proxy->getConduitDictionaryValue();
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	public function shouldAppearInConduitTransactions() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInConduitDictionary();
	}
	return false;
	}

	public function getConduitSearchParameterType() {
	return $this->newConduitSearchParameterType();
	}

	protected function newConduitSearchParameterType() {
	if ($this->proxy) {
	return $this->proxy->newConduitSearchParameterType();
	}
	return null;
	}

	public function getConduitEditParameterType() {
	return $this->newConduitEditParameterType();
	}

	protected function newConduitEditParameterType() {
	if ($this->proxy) {
	return $this->proxy->newConduitEditParameterType();
	}
	return null;
	}

	public function getCommentAction() {
	return $this->newCommentAction();
	}

	protected function newCommentAction() {
	if ($this->proxy) {
	return $this->proxy->newCommentAction();
	}
	return null;
	}


	/* -( Herald )------------------------------------------------------------- */


	/**
	* Return `true` to make this field available in Herald.
	*
	* @return bool True to expose the field in Herald.
	* @task herald
	*/
	public function shouldAppearInHerald() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInHerald();
	}
	return false;
	}


	/**
	* Get the name of the field in Herald. By default, this uses the
	* normal field name.
	*
	* @return string Herald field name.
	* @task herald
	*/
	public function getHeraldFieldName() {
	if ($this->proxy) {
	return $this->proxy->getHeraldFieldName();
	}
	return $this->getFieldName();
	}


	/**
	* Get the field value for evaluation by Herald.
	*
	* @return wild Field value.
	* @task herald
	*/
	public function getHeraldFieldValue() {
	if ($this->proxy) {
	return $this->proxy->getHeraldFieldValue();
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* Get the available conditions for this field in Herald.
	*
	* @return list<const> List of Herald condition constants.
	* @task herald
	*/
	public function getHeraldFieldConditions() {
	if ($this->proxy) {
	return $this->proxy->getHeraldFieldConditions();
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* Get the Herald value type for the given condition.
	*
	* @param const Herald condition constant.
	* @return const\|null Herald value type, or null to use the default.
	* @task herald
	*/
	public function getHeraldFieldValueType($condition) {
	if ($this->proxy) {
	return $this->proxy->getHeraldFieldValueType($condition);
	}
	return null;
	}

	public function getHeraldFieldStandardType() {
	if ($this->proxy) {
	return $this->proxy->getHeraldFieldStandardType();
	}
	return null;
	}

	public function getHeraldDatasource() {
	if ($this->proxy) {
	return $this->proxy->getHeraldDatasource();
	}
	return null;
	}


	public function shouldAppearInHeraldActions() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInHeraldActions();
	}
	return false;
	}


	public function getHeraldActionName() {
	if ($this->proxy) {
	return $this->proxy->getHeraldActionName();
	}

	return null;
	}


	public function getHeraldActionStandardType() {
	if ($this->proxy) {
	return $this->proxy->getHeraldActionStandardType();
	}

	return null;
	}


	public function getHeraldActionDescription($value) {
	if ($this->proxy) {
	return $this->proxy->getHeraldActionDescription($value);
	}

	return null;
	}


	public function getHeraldActionEffectDescription($value) {
	if ($this->proxy) {
	return $this->proxy->getHeraldActionEffectDescription($value);
	}

	return null;
	}


	public function getHeraldActionDatasource() {
	if ($this->proxy) {
	return $this->proxy->getHeraldActionDatasource();
	}

	return null;
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Jan 19, 17:13 (1 w, 5 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1126842
Default Alt Text: (309 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions