No OneTemporary
Actions

Size

120 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/maniphest/controller/ManiphestTaskDetailController.php b/src/applications/maniphest/controller/ManiphestTaskDetailController.php
	index 369986705c..60d3a81b1b 100644
	--- a/src/applications/maniphest/controller/ManiphestTaskDetailController.php
	+++ b/src/applications/maniphest/controller/ManiphestTaskDetailController.php
	@@ -1,558 +1,558 @@
	<?php

	final class ManiphestTaskDetailController extends ManiphestController {

	public function shouldAllowPublic() {
	return true;
	}

	public function handleRequest(AphrontRequest $request) {
	$viewer = $this->getViewer();
	$id = $request->getURIData('id');

	$task = id(new ManiphestTaskQuery())
	->setViewer($viewer)
	->withIDs(array($id))
	->needSubscriberPHIDs(true)
	->executeOne();
	if (!$task) {
	return new Aphront404Response();
	}

	$field_list = PhabricatorCustomField::getObjectFields(
	$task,
	PhabricatorCustomField::ROLE_VIEW);
	$field_list
	->setViewer($viewer)
	->readFieldsFromStorage($task);

	$edit_engine = id(new ManiphestEditEngine())
	->setViewer($viewer)
	->setTargetObject($task);

	$edge_types = array(
	ManiphestTaskHasCommitEdgeType::EDGECONST,
	ManiphestTaskHasRevisionEdgeType::EDGECONST,
	ManiphestTaskHasMockEdgeType::EDGECONST,
	PhabricatorObjectMentionedByObjectEdgeType::EDGECONST,
	PhabricatorObjectMentionsObjectEdgeType::EDGECONST,
	);

	$phid = $task->getPHID();

	$query = id(new PhabricatorEdgeQuery())
	->withSourcePHIDs(array($phid))
	->withEdgeTypes($edge_types);
	$edges = idx($query->execute(), $phid);
	$phids = array_fill_keys($query->getDestinationPHIDs(), true);

	if ($task->getOwnerPHID()) {
	$phids[$task->getOwnerPHID()] = true;
	}
	$phids[$task->getAuthorPHID()] = true;

	$phids = array_keys($phids);
	$handles = $viewer->loadHandles($phids);

	$timeline = $this->buildTransactionTimeline(
	$task,
	new ManiphestTransactionQuery());

	$monogram = $task->getMonogram();
	$crumbs = $this->buildApplicationCrumbs()
	->addTextCrumb($monogram)
	->setBorder(true);

	$header = $this->buildHeaderView($task);
	$details = $this->buildPropertyView($task, $field_list, $edges, $handles);
	$description = $this->buildDescriptionView($task);
	$curtain = $this->buildCurtain($task, $edit_engine);

	$title = pht('%s %s', $monogram, $task->getTitle());

	$comment_view = $edit_engine
	->buildEditEngineCommentView($task);

	$timeline->setQuoteRef($monogram);
	$comment_view->setTransactionTimeline($timeline);

	$related_tabs = array();
	$graph_menu = null;

	$graph_limit = 100;
	$task_graph = id(new ManiphestTaskGraph())
	->setViewer($viewer)
	->setSeedPHID($task->getPHID())
	->setLimit($graph_limit)
	->loadGraph();
	if (!$task_graph->isEmpty()) {
	$parent_type = ManiphestTaskDependedOnByTaskEdgeType::EDGECONST;
	$subtask_type = ManiphestTaskDependsOnTaskEdgeType::EDGECONST;
	$parent_map = $task_graph->getEdges($parent_type);
	$subtask_map = $task_graph->getEdges($subtask_type);
	$parent_list = idx($parent_map, $task->getPHID(), array());
	$subtask_list = idx($subtask_map, $task->getPHID(), array());
	$has_parents = (bool)$parent_list;
	$has_subtasks = (bool)$subtask_list;

	$search_text = pht('Search...');

	// First, get a count of direct parent tasks and subtasks. If there
	// are too many of these, we just don't draw anything. You can use
	// the search button to browse tasks with the search UI instead.
	$direct_count = count($parent_list) + count($subtask_list);

	if ($direct_count > $graph_limit) {
	$message = pht(
	'Task graph too large to display (this task is directly connected '.
	'to more than %s other tasks). Use %s to explore connected tasks.',
	$graph_limit,
	phutil_tag('strong', array(), $search_text));
	$message = phutil_tag('em', array(), $message);
	$graph_table = id(new PHUIPropertyListView())
	->addTextContent($message);
	} else {
	// If there aren't too many direct tasks, but there are too many total
	// tasks, we'll only render directly connected tasks.
	if ($task_graph->isOverLimit()) {
	$task_graph->setRenderOnlyAdjacentNodes(true);
	}
	$graph_table = $task_graph->newGraphTable();
	}

	$parents_uri = urisprintf(
	'/?subtaskIDs=%d#R',
	$task->getID());
	$parents_uri = $this->getApplicationURI($parents_uri);

	$subtasks_uri = urisprintf(
	'/?parentIDs=%d#R',
	$task->getID());
	$subtasks_uri = $this->getApplicationURI($subtasks_uri);

	$dropdown_menu = id(new PhabricatorActionListView())
	->setViewer($viewer)
	->addAction(
	id(new PhabricatorActionView())
	->setHref($parents_uri)
	->setName(pht('Search Parent Tasks'))
	->setDisabled(!$has_parents)
	->setIcon('fa-chevron-circle-up'))
	->addAction(
	id(new PhabricatorActionView())
	->setHref($subtasks_uri)
	->setName(pht('Search Subtasks'))
	->setDisabled(!$has_subtasks)
	->setIcon('fa-chevron-circle-down'));

	$graph_menu = id(new PHUIButtonView())
	->setTag('a')
	->setIcon('fa-search')
	->setText($search_text)
	->setDropdownMenu($dropdown_menu);

	$related_tabs[] = id(new PHUITabView())
	->setName(pht('Task Graph'))
	->setKey('graph')
	->appendChild($graph_table);
	}

	$related_tabs[] = $this->newMocksTab($task, $query);
	$related_tabs[] = $this->newMentionsTab($task, $query);

	$tab_view = null;

	$related_tabs = array_filter($related_tabs);
	if ($related_tabs) {
	$tab_group = new PHUITabGroupView();
	foreach ($related_tabs as $tab) {
	$tab_group->addTab($tab);
	}

	$related_header = id(new PHUIHeaderView())
	->setHeader(pht('Related Objects'));

	if ($graph_menu) {
	$related_header->addActionLink($graph_menu);
	}

	$tab_view = id(new PHUIObjectBoxView())
	->setHeader($related_header)
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->addTabGroup($tab_group);
	}

	$view = id(new PHUITwoColumnView())
	->setHeader($header)
	->setCurtain($curtain)
	->setMainColumn(
	array(
	$tab_view,
	$timeline,
	$comment_view,
	))
	->addPropertySection(pht('Description'), $description)
	->addPropertySection(pht('Details'), $details);


	return $this->newPage()
	->setTitle($title)
	->setCrumbs($crumbs)
	->setPageObjectPHIDs(
	array(
	$task->getPHID(),
	))
	->appendChild($view);

	}

	private function buildHeaderView(ManiphestTask $task) {
	$view = id(new PHUIHeaderView())
	->setHeader($task->getTitle())
	->setUser($this->getRequest()->getUser())
	->setPolicyObject($task);

	$priority_name = ManiphestTaskPriority::getTaskPriorityName(
	$task->getPriority());
	$priority_color = ManiphestTaskPriority::getTaskPriorityColor(
	$task->getPriority());

	$status = $task->getStatus();
	$status_name = ManiphestTaskStatus::renderFullDescription(
	$status, $priority_name);
	$view->addProperty(PHUIHeaderView::PROPERTY_STATUS, $status_name);

	$view->setHeaderIcon(ManiphestTaskStatus::getStatusIcon(
	$task->getStatus()).' '.$priority_color);

	if (ManiphestTaskPoints::getIsEnabled()) {
	$points = $task->getPoints();
	if ($points !== null) {
	$points_name = pht('%s %s',
	$task->getPoints(),
	ManiphestTaskPoints::getPointsLabel());
	$tag = id(new PHUITagView())
	->setName($points_name)
	->setShade('blue')
	->setType(PHUITagView::TYPE_SHADE);

	$view->addTag($tag);
	}
	}

	return $view;
	}


	private function buildCurtain(
	ManiphestTask $task,
	PhabricatorEditEngine $edit_engine) {
	$viewer = $this->getViewer();

	$id = $task->getID();
	$phid = $task->getPHID();

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

	$curtain = $this->newCurtainView($task);

	$curtain->addAction(
	id(new PhabricatorActionView())
	->setName(pht('Edit Task'))
	->setIcon('fa-pencil')
	->setHref($this->getApplicationURI("/task/edit/{$id}/"))
	->setDisabled(!$can_edit)
	->setWorkflow(!$can_edit));

	- $edit_config = $edit_engine->loadDefaultEditConfiguration();
	+ $edit_config = $edit_engine->loadDefaultEditConfiguration($task);
	$can_create = (bool)$edit_config;

	$can_reassign = $edit_engine->hasEditAccessToTransaction(
	ManiphestTransaction::TYPE_OWNER);

	if ($can_create) {
	$form_key = $edit_config->getIdentifier();
	$edit_uri = id(new PhutilURI("/task/edit/form/{$form_key}/"))
	->setQueryParam('parent', $id)
	->setQueryParam('template', $id)
	->setQueryParam('status', ManiphestTaskStatus::getDefaultStatus());
	$edit_uri = $this->getApplicationURI($edit_uri);
	} else {
	// TODO: This will usually give us a somewhat-reasonable error page, but
	// could be a bit cleaner.
	$edit_uri = "/task/edit/{$id}/";
	$edit_uri = $this->getApplicationURI($edit_uri);
	}

	$subtask_item = id(new PhabricatorActionView())
	->setName(pht('Create Subtask'))
	->setHref($edit_uri)
	->setIcon('fa-level-down')
	->setDisabled(!$can_create)
	->setWorkflow(!$can_create);

	$relationship_list = PhabricatorObjectRelationshipList::newForObject(
	$viewer,
	$task);

	$submenu_actions = array(
	$subtask_item,
	ManiphestTaskHasParentRelationship::RELATIONSHIPKEY,
	ManiphestTaskHasSubtaskRelationship::RELATIONSHIPKEY,
	ManiphestTaskMergeInRelationship::RELATIONSHIPKEY,
	ManiphestTaskCloseAsDuplicateRelationship::RELATIONSHIPKEY,
	);

	$task_submenu = $relationship_list->newActionSubmenu($submenu_actions)
	->setName(pht('Edit Related Tasks...'))
	->setIcon('fa-anchor');

	$curtain->addAction($task_submenu);

	$relationship_submenu = $relationship_list->newActionMenu();
	if ($relationship_submenu) {
	$curtain->addAction($relationship_submenu);
	}

	$owner_phid = $task->getOwnerPHID();
	$author_phid = $task->getAuthorPHID();
	$handles = $viewer->loadHandles(array($owner_phid, $author_phid));

	if ($owner_phid) {
	$image_uri = $handles[$owner_phid]->getImageURI();
	$image_href = $handles[$owner_phid]->getURI();
	$owner = $viewer->renderHandle($owner_phid)->render();
	$content = phutil_tag('strong', array(), $owner);
	$assigned_to = id(new PHUIHeadThingView())
	->setImage($image_uri)
	->setImageHref($image_href)
	->setContent($content);
	} else {
	$assigned_to = phutil_tag('em', array(), pht('None'));
	}

	$curtain->newPanel()
	->setHeaderText(pht('Assigned To'))
	->appendChild($assigned_to);

	$author_uri = $handles[$author_phid]->getImageURI();
	$author_href = $handles[$author_phid]->getURI();
	$author = $viewer->renderHandle($author_phid)->render();
	$content = phutil_tag('strong', array(), $author);
	$date = phabricator_date($task->getDateCreated(), $viewer);
	$content = pht('%s, %s', $content, $date);
	$authored_by = id(new PHUIHeadThingView())
	->setImage($author_uri)
	->setImageHref($author_href)
	->setContent($content);

	$curtain->newPanel()
	->setHeaderText(pht('Authored By'))
	->appendChild($authored_by);

	return $curtain;
	}

	private function buildPropertyView(
	ManiphestTask $task,
	PhabricatorCustomFieldList $field_list,
	array $edges,
	$handles) {

	$viewer = $this->getRequest()->getUser();
	$view = id(new PHUIPropertyListView())
	->setUser($viewer);

	$source = $task->getOriginalEmailSource();
	if ($source) {
	$subject = '[T'.$task->getID().'] '.$task->getTitle();
	$view->addProperty(
	pht('From Email'),
	phutil_tag(
	'a',
	array(
	'href' => 'mailto:'.$source.'?subject='.$subject,
	),
	$source));
	}

	$edge_types = array(
	ManiphestTaskHasRevisionEdgeType::EDGECONST
	=> pht('Differential Revisions'),
	);

	$revisions_commits = array();

	$commit_phids = array_keys(
	$edges[ManiphestTaskHasCommitEdgeType::EDGECONST]);
	if ($commit_phids) {
	$commit_drev = DiffusionCommitHasRevisionEdgeType::EDGECONST;
	$drev_edges = id(new PhabricatorEdgeQuery())
	->withSourcePHIDs($commit_phids)
	->withEdgeTypes(array($commit_drev))
	->execute();

	foreach ($commit_phids as $phid) {
	$revisions_commits[$phid] = $handles->renderHandle($phid)
	->setShowHovercard(true)
	->setShowStateIcon(true);
	$revision_phid = key($drev_edges[$phid][$commit_drev]);
	$revision_handle = $handles->getHandleIfExists($revision_phid);
	if ($revision_handle) {
	$task_drev = ManiphestTaskHasRevisionEdgeType::EDGECONST;
	unset($edges[$task_drev][$revision_phid]);
	$revisions_commits[$phid] = hsprintf(
	'%s / %s',
	$revision_handle->renderHovercardLink($revision_handle->getName()),
	$revisions_commits[$phid]);
	}
	}
	}

	foreach ($edge_types as $edge_type => $edge_name) {
	if (!$edges[$edge_type]) {
	continue;
	}

	$edge_handles = $viewer->loadHandles(array_keys($edges[$edge_type]));

	$edge_list = $edge_handles->renderList()
	->setShowStateIcons(true);

	$view->addProperty($edge_name, $edge_list);
	}

	if ($revisions_commits) {
	$view->addProperty(
	pht('Commits'),
	phutil_implode_html(phutil_tag('br'), $revisions_commits));
	}

	$field_list->appendFieldsToPropertyList(
	$task,
	$viewer,
	$view);

	if ($view->hasAnyProperties()) {
	return $view;
	}

	return null;
	}

	private function buildDescriptionView(ManiphestTask $task) {
	$viewer = $this->getViewer();

	$section = null;

	$description = $task->getDescription();
	if (strlen($description)) {
	$section = new PHUIPropertyListView();
	$section->addTextContent(
	phutil_tag(
	'div',
	array(
	'class' => 'phabricator-remarkup',
	),
	id(new PHUIRemarkupView($viewer, $description))
	->setContextObject($task)));
	}

	return $section;
	}

	private function newMocksTab(
	ManiphestTask $task,
	PhabricatorEdgeQuery $edge_query) {

	$mock_type = ManiphestTaskHasMockEdgeType::EDGECONST;
	$mock_phids = $edge_query->getDestinationPHIDs(array(), array($mock_type));
	if (!$mock_phids) {
	return null;
	}

	$viewer = $this->getViewer();
	$handles = $viewer->loadHandles($mock_phids);

	// TODO: It would be nice to render this as pinboard-style thumbnails,
	// similar to "{M123}", instead of a list of links.

	$view = id(new PHUIPropertyListView())
	->addProperty(pht('Mocks'), $handles->renderList());

	return id(new PHUITabView())
	->setName(pht('Mocks'))
	->setKey('mocks')
	->appendChild($view);
	}

	private function newMentionsTab(
	ManiphestTask $task,
	PhabricatorEdgeQuery $edge_query) {

	$in_type = PhabricatorObjectMentionedByObjectEdgeType::EDGECONST;
	$out_type = PhabricatorObjectMentionsObjectEdgeType::EDGECONST;

	$in_phids = $edge_query->getDestinationPHIDs(array(), array($in_type));
	$out_phids = $edge_query->getDestinationPHIDs(array(), array($out_type));

	// Filter out any mentioned users from the list. These are not generally
	// very interesting to show in a relationship summary since they usually
	// end up as subscribers anyway.

	$user_type = PhabricatorPeopleUserPHIDType::TYPECONST;
	foreach ($out_phids as $key => $out_phid) {
	if (phid_get_type($out_phid) == $user_type) {
	unset($out_phids[$key]);
	}
	}

	if (!$in_phids && !$out_phids) {
	return null;
	}

	$viewer = $this->getViewer();
	$in_handles = $viewer->loadHandles($in_phids);
	$out_handles = $viewer->loadHandles($out_phids);

	$in_handles = $this->getCompleteHandles($in_handles);
	$out_handles = $this->getCompleteHandles($out_handles);

	if (!count($in_handles) && !count($out_handles)) {
	return null;
	}

	$view = new PHUIPropertyListView();

	if (count($in_handles)) {
	$view->addProperty(pht('Mentioned In'), $in_handles->renderList());
	}

	if (count($out_handles)) {
	$view->addProperty(pht('Mentioned Here'), $out_handles->renderList());
	}

	return id(new PHUITabView())
	->setName(pht('Mentions'))
	->setKey('mentions')
	->appendChild($view);
	}

	private function getCompleteHandles(PhabricatorHandleList $handles) {
	$phids = array();

	foreach ($handles as $phid => $handle) {
	if (!$handle->isComplete()) {
	continue;
	}
	$phids[] = $phid;
	}

	return $handles->newSublist($phids);
	}


	}
	diff --git a/src/applications/project/controller/PhabricatorProjectBoardViewController.php b/src/applications/project/controller/PhabricatorProjectBoardViewController.php
	index 7e682fb258..f504d43426 100644
	--- a/src/applications/project/controller/PhabricatorProjectBoardViewController.php
	+++ b/src/applications/project/controller/PhabricatorProjectBoardViewController.php
	@@ -1,1078 +1,1078 @@
	<?php

	final class PhabricatorProjectBoardViewController
	extends PhabricatorProjectBoardController {

	const BATCH_EDIT_ALL = 'all';

	private $id;
	private $slug;
	private $queryKey;
	private $sortKey;
	private $showHidden;

	public function shouldAllowPublic() {
	return true;
	}

	public function handleRequest(AphrontRequest $request) {
	$viewer = $request->getUser();

	$response = $this->loadProject();
	if ($response) {
	return $response;
	}

	$project = $this->getProject();

	$this->readRequestState();

	$board_uri = $this->getApplicationURI('board/'.$project->getID().'/');

	$search_engine = id(new ManiphestTaskSearchEngine())
	->setViewer($viewer)
	->setBaseURI($board_uri)
	->setIsBoardView(true);

	if ($request->isFormPost() && !$request->getBool('initialize')) {
	$saved = $search_engine->buildSavedQueryFromRequest($request);
	$search_engine->saveQuery($saved);
	$filter_form = id(new AphrontFormView())
	->setUser($viewer);
	$search_engine->buildSearchForm($filter_form, $saved);
	if ($search_engine->getErrors()) {
	return $this->newDialog()
	->setWidth(AphrontDialogView::WIDTH_FULL)
	->setTitle(pht('Advanced Filter'))
	->appendChild($filter_form->buildLayoutView())
	->setErrors($search_engine->getErrors())
	->setSubmitURI($board_uri)
	->addSubmitButton(pht('Apply Filter'))
	->addCancelButton($board_uri);
	}
	return id(new AphrontRedirectResponse())->setURI(
	$this->getURIWithState(
	$search_engine->getQueryResultsPageURI($saved->getQueryKey())));
	}

	$query_key = $this->getDefaultFilter($project);

	$request_query = $request->getStr('filter');
	if (strlen($request_query)) {
	$query_key = $request_query;
	}

	$uri_query = $request->getURIData('queryKey');
	if (strlen($uri_query)) {
	$query_key = $uri_query;
	}

	$this->queryKey = $query_key;

	$custom_query = null;
	if ($search_engine->isBuiltinQuery($query_key)) {
	$saved = $search_engine->buildSavedQueryFromBuiltin($query_key);
	} else {
	$saved = id(new PhabricatorSavedQueryQuery())
	->setViewer($viewer)
	->withQueryKeys(array($query_key))
	->executeOne();

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

	$custom_query = $saved;
	}

	if ($request->getURIData('filter')) {
	$filter_form = id(new AphrontFormView())
	->setUser($viewer);
	$search_engine->buildSearchForm($filter_form, $saved);

	return $this->newDialog()
	->setWidth(AphrontDialogView::WIDTH_FULL)
	->setTitle(pht('Advanced Filter'))
	->appendChild($filter_form->buildLayoutView())
	->setSubmitURI($board_uri)
	->addSubmitButton(pht('Apply Filter'))
	->addCancelButton($board_uri);
	}

	$task_query = $search_engine->buildQueryFromSavedQuery($saved);

	$select_phids = array($project->getPHID());
	if ($project->getHasSubprojects() \|\| $project->getHasMilestones()) {
	$descendants = id(new PhabricatorProjectQuery())
	->setViewer($viewer)
	->withAncestorProjectPHIDs($select_phids)
	->execute();
	foreach ($descendants as $descendant) {
	$select_phids[] = $descendant->getPHID();
	}
	}

	$tasks = $task_query
	->withEdgeLogicPHIDs(
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
	PhabricatorQueryConstraint::OPERATOR_ANCESTOR,
	array($select_phids))
	->setOrder(ManiphestTaskQuery::ORDER_PRIORITY)
	->setViewer($viewer)
	->execute();
	$tasks = mpull($tasks, null, 'getPHID');

	$board_phid = $project->getPHID();

	// Regardless of display order, pass tasks to the layout engine in ID order
	// so layout is consistent.
	$board_tasks = msort($tasks, 'getID');

	$layout_engine = id(new PhabricatorBoardLayoutEngine())
	->setViewer($viewer)
	->setBoardPHIDs(array($board_phid))
	->setObjectPHIDs(array_keys($board_tasks))
	->setFetchAllBoards(true)
	->executeLayout();

	$columns = $layout_engine->getColumns($board_phid);
	if (!$columns \|\| !$project->getHasWorkboard()) {
	$has_normal_columns = false;

	foreach ($columns as $column) {
	if (!$column->getProxyPHID()) {
	$has_normal_columns = true;
	break;
	}
	}

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

	if (!$has_normal_columns) {
	if (!$can_edit) {
	$content = $this->buildNoAccessContent($project);
	} else {
	$content = $this->buildInitializeContent($project);
	}
	} else {
	if (!$can_edit) {
	$content = $this->buildDisabledContent($project);
	} else {
	$content = $this->buildEnableContent($project);
	}
	}

	if ($content instanceof AphrontResponse) {
	return $content;
	}

	$nav = $this->getProfileMenu();
	$nav->selectFilter(PhabricatorProject::ITEM_WORKBOARD);

	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->addTextCrumb(pht('Workboard'));

	return $this->newPage()
	->setTitle(
	array(
	$project->getDisplayName(),
	pht('Workboard'),
	))
	->setNavigation($nav)
	->setCrumbs($crumbs)
	->appendChild($content);
	}

	$task_can_edit_map = id(new PhabricatorPolicyFilter())
	->setViewer($viewer)
	->requireCapabilities(array(PhabricatorPolicyCapability::CAN_EDIT))
	->apply($tasks);

	// If this is a batch edit, select the editable tasks in the chosen column
	// and ship the user into the batch editor.
	$batch_edit = $request->getStr('batch');
	if ($batch_edit) {
	if ($batch_edit !== self::BATCH_EDIT_ALL) {
	$column_id_map = mpull($columns, null, 'getID');
	$batch_column = idx($column_id_map, $batch_edit);
	if (!$batch_column) {
	return new Aphront404Response();
	}

	$batch_task_phids = $layout_engine->getColumnObjectPHIDs(
	$board_phid,
	$batch_column->getPHID());

	foreach ($batch_task_phids as $key => $batch_task_phid) {
	if (empty($task_can_edit_map[$batch_task_phid])) {
	unset($batch_task_phids[$key]);
	}
	}

	$batch_tasks = array_select_keys($tasks, $batch_task_phids);
	} else {
	$batch_tasks = $task_can_edit_map;
	}

	if (!$batch_tasks) {
	$cancel_uri = $this->getURIWithState($board_uri);
	return $this->newDialog()
	->setTitle(pht('No Editable Tasks'))
	->appendParagraph(
	pht(
	'The selected column contains no visible tasks which you '.
	'have permission to edit.'))
	->addCancelButton($board_uri);
	}

	$batch_ids = mpull($batch_tasks, 'getID');
	$batch_ids = implode(',', $batch_ids);

	$batch_uri = new PhutilURI('/maniphest/batch/');
	$batch_uri->setQueryParam('board', $this->id);
	$batch_uri->setQueryParam('batch', $batch_ids);
	return id(new AphrontRedirectResponse())
	->setURI($batch_uri);
	}

	$board_id = celerity_generate_unique_node_id();

	$board = id(new PHUIWorkboardView())
	->setUser($viewer)
	->setID($board_id)
	->addSigil('jx-workboard')
	->setMetadata(
	array(
	'boardPHID' => $project->getPHID(),
	));

	$visible_columns = array();
	$column_phids = array();
	$visible_phids = array();
	foreach ($columns as $column) {
	if (!$this->showHidden) {
	if ($column->isHidden()) {
	continue;
	}
	}

	$proxy = $column->getProxy();
	if ($proxy && !$proxy->isMilestone()) {
	// TODO: For now, don't show subproject columns because we can't
	// handle tasks with multiple positions yet.
	continue;
	}

	$task_phids = $layout_engine->getColumnObjectPHIDs(
	$board_phid,
	$column->getPHID());

	$column_tasks = array_select_keys($tasks, $task_phids);

	// If we aren't using "natural" order, reorder the column by the original
	// query order.
	if ($this->sortKey != PhabricatorProjectColumn::ORDER_NATURAL) {
	$column_tasks = array_select_keys($column_tasks, array_keys($tasks));
	}

	$column_phid = $column->getPHID();

	$visible_columns[$column_phid] = $column;
	$column_phids[$column_phid] = $column_tasks;

	foreach ($column_tasks as $phid => $task) {
	$visible_phids[$phid] = $phid;
	}
	}

	$rendering_engine = id(new PhabricatorBoardRenderingEngine())
	->setViewer($viewer)
	->setObjects(array_select_keys($tasks, $visible_phids))
	->setEditMap($task_can_edit_map)
	->setExcludedProjectPHIDs($select_phids);

	$templates = array();
	$column_maps = array();
	$all_tasks = array();
	foreach ($visible_columns as $column_phid => $column) {
	$column_tasks = $column_phids[$column_phid];

	$panel = id(new PHUIWorkpanelView())
	->setHeader($column->getDisplayName())
	->setSubHeader($column->getDisplayType())
	->addSigil('workpanel');

	$proxy = $column->getProxy();
	if ($proxy) {
	$proxy_id = $proxy->getID();
	$href = $this->getApplicationURI("view/{$proxy_id}/");
	$panel->setHref($href);
	}

	$header_icon = $column->getHeaderIcon();
	if ($header_icon) {
	$panel->setHeaderIcon($header_icon);
	}

	$display_class = $column->getDisplayClass();
	if ($display_class) {
	$panel->addClass($display_class);
	}

	if ($column->isHidden()) {
	$panel->addClass('project-panel-hidden');
	}

	$column_menu = $this->buildColumnMenu($project, $column);
	$panel->addHeaderAction($column_menu);

	$count_tag = id(new PHUITagView())
	->setType(PHUITagView::TYPE_SHADE)
	->setShade(PHUITagView::COLOR_BLUE)
	->addSigil('column-points')
	->setName(
	javelin_tag(
	'span',
	array(
	'sigil' => 'column-points-content',
	),
	pht('-')))
	->setStyle('display: none');

	$panel->setHeaderTag($count_tag);

	$cards = id(new PHUIObjectItemListView())
	->setUser($viewer)
	->setFlush(true)
	->setAllowEmptyList(true)
	->addSigil('project-column')
	->setItemClass('phui-workcard')
	->setMetadata(
	array(
	'columnPHID' => $column->getPHID(),
	'pointLimit' => $column->getPointLimit(),
	));

	foreach ($column_tasks as $task) {
	$object_phid = $task->getPHID();

	$card = $rendering_engine->renderCard($object_phid);
	$templates[$object_phid] = hsprintf('%s', $card->getItem());
	$column_maps[$column_phid][] = $object_phid;

	$all_tasks[$object_phid] = $task;
	}

	$panel->setCards($cards);
	$board->addPanel($panel);
	}

	$behavior_config = array(
	'moveURI' => $this->getApplicationURI('move/'.$project->getID().'/'),
	'createURI' => $this->getCreateURI(),
	'uploadURI' => '/file/dropupload/',
	'coverURI' => $this->getApplicationURI('cover/'),
	'chunkThreshold' => PhabricatorFileStorageEngine::getChunkThreshold(),
	'pointsEnabled' => ManiphestTaskPoints::getIsEnabled(),

	'boardPHID' => $project->getPHID(),
	'order' => $this->sortKey,
	'templateMap' => $templates,
	'columnMaps' => $column_maps,
	'orderMaps' => mpull($all_tasks, 'getWorkboardOrderVectors'),
	'propertyMaps' => mpull($all_tasks, 'getWorkboardProperties'),

	'boardID' => $board_id,
	'projectPHID' => $project->getPHID(),
	);
	$this->initBehavior('project-boards', $behavior_config);


	$sort_menu = $this->buildSortMenu(
	$viewer,
	$project,
	$this->sortKey);

	$filter_menu = $this->buildFilterMenu(
	$viewer,
	$project,
	$custom_query,
	$search_engine,
	$query_key);

	$manage_menu = $this->buildManageMenu($project, $this->showHidden);

	$header_link = phutil_tag(
	'a',
	array(
	'href' => $this->getApplicationURI('profile/'.$project->getID().'/'),
	),
	$project->getName());

	$board_box = id(new PHUIBoxView())
	->appendChild($board)
	->addClass('project-board-wrapper');

	$nav = $this->getProfileMenu();

	$divider = id(new PHUIListItemView())
	->setType(PHUIListItemView::TYPE_DIVIDER);
	$fullscreen = $this->buildFullscreenMenu();

	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->addTextCrumb(pht('Workboard'));
	$crumbs->setBorder(true);

	$crumbs->addAction($sort_menu);
	$crumbs->addAction($filter_menu);
	$crumbs->addAction($divider);
	$crumbs->addAction($manage_menu);
	$crumbs->addAction($fullscreen);

	$page = $this->newPage()
	->setTitle(
	array(
	$project->getDisplayName(),
	pht('Workboard'),
	))
	->setPageObjectPHIDs(array($project->getPHID()))
	->setShowFooter(false)
	->setNavigation($nav)
	->setCrumbs($crumbs)
	->addQuicksandConfig(
	array(
	'boardConfig' => $behavior_config,
	))
	->appendChild(
	array(
	$board_box,
	));

	$background = $project->getDisplayWorkboardBackgroundColor();
	require_celerity_resource('phui-workboard-color-css');
	if ($background !== null) {
	$background_color_class = "phui-workboard-{$background}";

	$page->addClass('phui-workboard-color');
	$page->addClass($background_color_class);
	} else {
	$page->addClass('phui-workboard-no-color');
	}

	return $page;
	}

	private function readRequestState() {
	$request = $this->getRequest();
	$project = $this->getProject();

	$this->showHidden = $request->getBool('hidden');
	$this->id = $project->getID();

	$sort_key = $this->getDefaultSort($project);

	$request_sort = $request->getStr('order');
	if ($this->isValidSort($request_sort)) {
	$sort_key = $request_sort;
	}

	$this->sortKey = $sort_key;
	}

	private function getDefaultSort(PhabricatorProject $project) {
	$default_sort = $project->getDefaultWorkboardSort();

	if ($this->isValidSort($default_sort)) {
	return $default_sort;
	}

	return PhabricatorProjectColumn::DEFAULT_ORDER;
	}

	private function getDefaultFilter(PhabricatorProject $project) {
	$default_filter = $project->getDefaultWorkboardFilter();

	if (strlen($default_filter)) {
	return $default_filter;
	}

	return 'open';
	}

	private function isValidSort($sort) {
	switch ($sort) {
	case PhabricatorProjectColumn::ORDER_NATURAL:
	case PhabricatorProjectColumn::ORDER_PRIORITY:
	return true;
	}

	return false;
	}

	private function buildSortMenu(
	PhabricatorUser $viewer,
	PhabricatorProject $project,
	$sort_key) {

	$sort_icon = id(new PHUIIconView())
	->setIcon('fa-sort-amount-asc bluegrey');

	$named = array(
	PhabricatorProjectColumn::ORDER_NATURAL => pht('Natural'),
	PhabricatorProjectColumn::ORDER_PRIORITY => pht('Sort by Priority'),
	);

	$base_uri = $this->getURIWithState();

	$items = array();
	foreach ($named as $key => $name) {
	$is_selected = ($key == $sort_key);
	if ($is_selected) {
	$active_order = $name;
	}

	$item = id(new PhabricatorActionView())
	->setIcon('fa-sort-amount-asc')
	->setSelected($is_selected)
	->setName($name);

	$uri = $base_uri->alter('order', $key);
	$item->setHref($uri);

	$items[] = $item;
	}

	$id = $project->getID();

	$save_uri = "default/{$id}/sort/";
	$save_uri = $this->getApplicationURI($save_uri);
	$save_uri = $this->getURIWithState($save_uri, $force = true);

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

	$items[] = id(new PhabricatorActionView())
	->setIcon('fa-floppy-o')
	->setName(pht('Save as Default'))
	->setHref($save_uri)
	->setWorkflow(true)
	->setDisabled(!$can_edit);

	$sort_menu = id(new PhabricatorActionListView())
	->setUser($viewer);
	foreach ($items as $item) {
	$sort_menu->addAction($item);
	}

	$sort_button = id(new PHUIListItemView())
	->setName($active_order)
	->setIcon('fa-sort-amount-asc')
	->setHref('#')
	->addSigil('boards-dropdown-menu')
	->setMetadata(
	array(
	'items' => hsprintf('%s', $sort_menu),
	));

	return $sort_button;
	}

	private function buildFilterMenu(
	PhabricatorUser $viewer,
	PhabricatorProject $project,
	$custom_query,
	PhabricatorApplicationSearchEngine $engine,
	$query_key) {

	$named = array(
	'open' => pht('Open Tasks'),
	'all' => pht('All Tasks'),
	);

	if ($viewer->isLoggedIn()) {
	$named['assigned'] = pht('Assigned to Me');
	}

	if ($custom_query) {
	$named[$custom_query->getQueryKey()] = pht('Custom Filter');
	}

	$items = array();
	foreach ($named as $key => $name) {
	$is_selected = ($key == $query_key);
	if ($is_selected) {
	$active_filter = $name;
	}

	$is_custom = false;
	if ($custom_query) {
	$is_custom = ($key == $custom_query->getQueryKey());
	}

	$item = id(new PhabricatorActionView())
	->setIcon('fa-search')
	->setSelected($is_selected)
	->setName($name);

	if ($is_custom) {
	$uri = $this->getApplicationURI(
	'board/'.$this->id.'/filter/query/'.$key.'/');
	$item->setWorkflow(true);
	} else {
	$uri = $engine->getQueryResultsPageURI($key);
	}

	$uri = $this->getURIWithState($uri)
	->setQueryParam('filter', null);
	$item->setHref($uri);

	$items[] = $item;
	}

	$id = $project->getID();

	$filter_uri = $this->getApplicationURI("board/{$id}/filter/");
	$filter_uri = $this->getURIWithState($filter_uri, $force = true);

	$items[] = id(new PhabricatorActionView())
	->setIcon('fa-cog')
	->setHref($filter_uri)
	->setWorkflow(true)
	->setName(pht('Advanced Filter...'));

	$save_uri = "default/{$id}/filter/";
	$save_uri = $this->getApplicationURI($save_uri);
	$save_uri = $this->getURIWithState($save_uri, $force = true);

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

	$items[] = id(new PhabricatorActionView())
	->setIcon('fa-floppy-o')
	->setName(pht('Save as Default'))
	->setHref($save_uri)
	->setWorkflow(true)
	->setDisabled(!$can_edit);

	$filter_menu = id(new PhabricatorActionListView())
	->setUser($viewer);
	foreach ($items as $item) {
	$filter_menu->addAction($item);
	}

	$filter_button = id(new PHUIListItemView())
	->setName($active_filter)
	->setIcon('fa-search')
	->setHref('#')
	->addSigil('boards-dropdown-menu')
	->setMetadata(
	array(
	'items' => hsprintf('%s', $filter_menu),
	));

	return $filter_button;
	}

	private function buildManageMenu(
	PhabricatorProject $project,
	$show_hidden) {

	$request = $this->getRequest();
	$viewer = $request->getUser();

	$id = $project->getID();

	$manage_uri = $this->getApplicationURI("board/{$id}/manage/");
	$add_uri = $this->getApplicationURI("board/{$id}/edit/");

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

	$manage_items = array();

	$manage_items[] = id(new PhabricatorActionView())
	->setIcon('fa-plus')
	->setName(pht('Add Column'))
	->setHref($add_uri)
	->setDisabled(!$can_edit)
	->setWorkflow(true);

	$manage_items[] = id(new PhabricatorActionView())
	->setIcon('fa-pencil')
	->setName(pht('Manage Board'))
	->setHref($manage_uri);

	if ($show_hidden) {
	$hidden_uri = $this->getURIWithState()
	->setQueryParam('hidden', null);
	$hidden_icon = 'fa-eye-slash';
	$hidden_text = pht('Hide Hidden Columns');
	} else {
	$hidden_uri = $this->getURIWithState()
	->setQueryParam('hidden', 'true');
	$hidden_icon = 'fa-eye';
	$hidden_text = pht('Show Hidden Columns');
	}

	$manage_items[] = id(new PhabricatorActionView())
	->setIcon($hidden_icon)
	->setName($hidden_text)
	->setHref($hidden_uri);

	$batch_edit_uri = $request->getRequestURI();
	$batch_edit_uri->setQueryParam('batch', self::BATCH_EDIT_ALL);
	$can_batch_edit = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	PhabricatorApplication::getByClass('PhabricatorManiphestApplication'),
	ManiphestBulkEditCapability::CAPABILITY);

	$manage_items[] = id(new PhabricatorActionView())
	->setIcon('fa-list-ul')
	->setName(pht('Batch Edit Visible Tasks...'))
	->setHref($batch_edit_uri)
	->setDisabled(!$can_batch_edit);

	$manage_menu = id(new PhabricatorActionListView())
	->setUser($viewer);
	foreach ($manage_items as $item) {
	$manage_menu->addAction($item);
	}

	$manage_button = id(new PHUIListItemView())
	->setIcon('fa-cog')
	->setHref('#')
	->addSigil('boards-dropdown-menu')
	->addSigil('has-tooltip')
	->setMetadata(
	array(
	'tip' => pht('Manage'),
	'align' => 'S',
	'items' => hsprintf('%s', $manage_menu),
	));

	return $manage_button;
	}

	private function buildFullscreenMenu() {

	$up = id(new PHUIListItemView())
	->setIcon('fa-arrows-alt')
	->setHref('#')
	->addClass('phui-workboard-expand-icon')
	->addSigil('jx-toggle-class')
	->addSigil('has-tooltip')
	->setMetaData(array(
	'tip' => pht('Fullscreen'),
	'map' => array(
	'phabricator-standard-page' => 'phui-workboard-fullscreen',
	),
	));

	return $up;
	}

	private function buildColumnMenu(
	PhabricatorProject $project,
	PhabricatorProjectColumn $column) {

	$request = $this->getRequest();
	$viewer = $request->getUser();

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

	$column_items = array();

	if ($column->getProxyPHID()) {
	$default_phid = $column->getProxyPHID();
	} else {
	$default_phid = $column->getProjectPHID();
	}

	$column_items[] = id(new PhabricatorActionView())
	->setIcon('fa-plus')
	->setName(pht('Create Task...'))
	->setHref($this->getCreateURI())
	->addSigil('column-add-task')
	->setMetadata(
	array(
	'columnPHID' => $column->getPHID(),
	'boardPHID' => $project->getPHID(),
	'projectPHID' => $default_phid,
	));

	$batch_edit_uri = $request->getRequestURI();
	$batch_edit_uri->setQueryParam('batch', $column->getID());
	$can_batch_edit = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	PhabricatorApplication::getByClass('PhabricatorManiphestApplication'),
	ManiphestBulkEditCapability::CAPABILITY);

	$column_items[] = id(new PhabricatorActionView())
	->setIcon('fa-list-ul')
	->setName(pht('Batch Edit Tasks...'))
	->setHref($batch_edit_uri)
	->setDisabled(!$can_batch_edit);

	$can_hide = ($can_edit && !$column->isDefaultColumn());
	$hide_uri = 'board/'.$this->id.'/hide/'.$column->getID().'/';
	$hide_uri = $this->getApplicationURI($hide_uri);
	$hide_uri = $this->getURIWithState($hide_uri);

	if (!$column->isHidden()) {
	$column_items[] = id(new PhabricatorActionView())
	->setName(pht('Hide Column'))
	->setIcon('fa-eye-slash')
	->setHref($hide_uri)
	->setDisabled(!$can_hide)
	->setWorkflow(true);
	} else {
	$column_items[] = id(new PhabricatorActionView())
	->setName(pht('Show Column'))
	->setIcon('fa-eye')
	->setHref($hide_uri)
	->setDisabled(!$can_hide)
	->setWorkflow(true);
	}

	$column_menu = id(new PhabricatorActionListView())
	->setUser($viewer);
	foreach ($column_items as $item) {
	$column_menu->addAction($item);
	}

	$column_button = id(new PHUIIconView())
	->setIcon('fa-caret-down')
	->setHref('#')
	->addSigil('boards-dropdown-menu')
	->setMetadata(
	array(
	'items' => hsprintf('%s', $column_menu),
	));

	return $column_button;
	}


	/**
	* Add current state parameters (like order and the visibility of hidden
	* columns) to a URI.
	*
	* This allows actions which toggle or adjust one piece of state to keep
	* the rest of the board state persistent. If no URI is provided, this method
	* starts with the request URI.
	*
	* @param string\|null URI to add state parameters to.
	* @param bool True to explicitly include all state.
	* @return PhutilURI URI with state parameters.
	*/
	private function getURIWithState($base = null, $force = false) {
	$project = $this->getProject();

	if ($base === null) {
	$base = $this->getRequest()->getRequestURI();
	}

	$base = new PhutilURI($base);

	if ($force \|\| ($this->sortKey != $this->getDefaultSort($project))) {
	$base->setQueryParam('order', $this->sortKey);
	} else {
	$base->setQueryParam('order', null);
	}

	if ($force \|\| ($this->queryKey != $this->getDefaultFilter($project))) {
	$base->setQueryParam('filter', $this->queryKey);
	} else {
	$base->setQueryParam('filter', null);
	}

	$base->setQueryParam('hidden', $this->showHidden ? 'true' : null);

	return $base;
	}

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

	// TODO: This should be cleaned up, but maybe we're going to make options
	// for each column or board?
	$edit_config = id(new ManiphestEditEngine())
	->setViewer($viewer)
	- ->loadDefaultEditConfiguration();
	+ ->loadDefaultEditConfiguration(new ManiphestTask());
	if ($edit_config) {
	$form_key = $edit_config->getIdentifier();
	$create_uri = "/maniphest/task/edit/form/{$form_key}/";
	} else {
	$create_uri = '/maniphest/task/edit/';
	}

	return $create_uri;
	}


	private function buildInitializeContent(PhabricatorProject $project) {
	$request = $this->getRequest();
	$viewer = $this->getViewer();

	$type = $request->getStr('initialize-type');

	$id = $project->getID();

	$profile_uri = $this->getApplicationURI("profile/{$id}/");
	$board_uri = $this->getApplicationURI("board/{$id}/");
	$import_uri = $this->getApplicationURI("board/{$id}/import/");

	$set_default = $request->getBool('default');
	if ($set_default) {
	$this
	->getProfileMenuEngine()
	->adjustDefault(PhabricatorProject::ITEM_WORKBOARD);
	}

	if ($request->isFormPost()) {
	if ($type == 'backlog-only') {
	$column = PhabricatorProjectColumn::initializeNewColumn($viewer)
	->setSequence(0)
	->setProperty('isDefault', true)
	->setProjectPHID($project->getPHID())
	->save();

	$project->setHasWorkboard(1)->save();

	return id(new AphrontRedirectResponse())
	->setURI($board_uri);
	} else {
	return id(new AphrontRedirectResponse())
	->setURI($import_uri);
	}
	}

	// TODO: Tailor this UI if the project is already a parent project. We
	// should not offer options for creating a parent project workboard, since
	// they can't have their own columns.

	$new_selector = id(new AphrontFormRadioButtonControl())
	->setLabel(pht('Columns'))
	->setName('initialize-type')
	->setValue('backlog-only')
	->addButton(
	'backlog-only',
	pht('New Empty Board'),
	pht('Create a new board with just a backlog column.'))
	->addButton(
	'import',
	pht('Import Columns'),
	pht('Import board columns from another project.'));

	$default_checkbox = id(new AphrontFormCheckboxControl())
	->setLabel(pht('Make Default'))
	->addCheckbox(
	'default',
	1,
	pht('Make the workboard the default view for this project.'),
	true);

	$form = id(new AphrontFormView())
	->setUser($viewer)
	->addHiddenInput('initialize', 1)
	->appendRemarkupInstructions(
	pht('The workboard for this project has not been created yet.'))
	->appendControl($new_selector)
	->appendControl($default_checkbox)
	->appendControl(
	id(new AphrontFormSubmitControl())
	->addCancelButton($profile_uri)
	->setValue(pht('Create Workboard')));

	$box = id(new PHUIObjectBoxView())
	->setHeaderText(pht('Create Workboard'))
	->setForm($form);

	return $box;
	}

	private function buildNoAccessContent(PhabricatorProject $project) {
	$viewer = $this->getViewer();

	$id = $project->getID();

	$profile_uri = $this->getApplicationURI("profile/{$id}/");

	return $this->newDialog()
	->setTitle(pht('Unable to Create Workboard'))
	->appendParagraph(
	pht(
	'The workboard for this project has not been created yet, '.
	'but you do not have permission to create it. Only users '.
	'who can edit this project can create a workboard for it.'))
	->addCancelButton($profile_uri);
	}


	private function buildEnableContent(PhabricatorProject $project) {
	$request = $this->getRequest();
	$viewer = $this->getViewer();

	$id = $project->getID();
	$profile_uri = $this->getApplicationURI("profile/{$id}/");
	$board_uri = $this->getApplicationURI("board/{$id}/");

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

	$xactions[] = id(new PhabricatorProjectTransaction())
	->setTransactionType(PhabricatorProjectTransaction::TYPE_HASWORKBOARD)
	->setNewValue(1);

	id(new PhabricatorProjectTransactionEditor())
	->setActor($viewer)
	->setContentSourceFromRequest($request)
	->setContinueOnNoEffect(true)
	->setContinueOnMissingFields(true)
	->applyTransactions($project, $xactions);

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

	return $this->newDialog()
	->setTitle(pht('Workboard Disabled'))
	->addHiddenInput('initialize', 1)
	->appendParagraph(
	pht(
	'This workboard has been disabled, but can be restored to its '.
	'former glory.'))
	->addCancelButton($profile_uri)
	->addSubmitButton(pht('Enable Workboard'));
	}

	private function buildDisabledContent(PhabricatorProject $project) {
	$viewer = $this->getViewer();

	$id = $project->getID();

	$profile_uri = $this->getApplicationURI("profile/{$id}/");

	return $this->newDialog()
	->setTitle(pht('Workboard Disabled'))
	->appendParagraph(
	pht(
	'This workboard has been disabled, and you do not have permission '.
	'to enable it. Only users who can edit this project can restore '.
	'the workboard.'))
	->addCancelButton($profile_uri);
	}

	}
	diff --git a/src/applications/transactions/editengine/PhabricatorEditEngine.php b/src/applications/transactions/editengine/PhabricatorEditEngine.php
	index 82af2143c7..75f906f9bf 100644
	--- a/src/applications/transactions/editengine/PhabricatorEditEngine.php
	+++ b/src/applications/transactions/editengine/PhabricatorEditEngine.php
	@@ -1,2334 +1,2343 @@
	<?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;
	private $hideHeader;

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

	public function setHideHeader($hide_header) {
	$this->hideHeader = $hide_header;
	return $this;
	}

	public function getHideHeader() {
	return $this->hideHeader;
	}


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


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

	public function getFieldsForConfig(
	PhabricatorEditEngineConfiguration $config) {

	$object = $this->newEditableObject();

	$this->editEngineConfiguration = $config;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return $fields;
	}

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

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

	return ($object instanceof PhabricatorEditEngineSubtypeInterface);
	}

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


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


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


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

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

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


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


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


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


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


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


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


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


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


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


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


	/**
	* 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 capabilitiy 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();
	+ $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();

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

	$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);
	$header_icon = 'fa-plus-square';
	} else {
	$header_text = $this->getObjectEditTitleText($object);
	$header_icon = 'fa-pencil';
	}

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

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

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

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

	if ($this->getHideHeader()) {
	$header = null;
	$crumbs->setBorder(false);
	} else {
	$header = id(new PHUIHeaderView())
	->setHeader($header_text)
	->setHeaderIcon($header_icon);
	$crumbs->setBorder(true);
	}

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

	$box = id(new PHUIObjectBoxView())
	->setUser($viewer)
	->setHeaderText($this->getObjectName())
	->setValidationException($validation_exception)
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->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();

	if ($header) {
	$view->setHeader($header);
	}

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

	return $controller->newPage()
	->setTitle($header_text)
	->setCrumbs($crumbs)
	->appendChild($view);
	}

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

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

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

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

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

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

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

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

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

	$form->appendControl($buttons);
	}

	return $form;
	}

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

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

	$viewer = $this->getViewer();

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

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

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

	return $action_button;
	}

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

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

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

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

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

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

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

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

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

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

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

	return $actions;
	}


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

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

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

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

	if (!$field) {
	return false;
	}

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

	return true;
	}


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

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


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

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

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

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

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

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

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

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

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

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

	$crumbs->addAction($action);
	}


	/**
	* Build a raw description of available "Create New Object" UI options so
	* other methods can build menus or buttons.
	*/
	private 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();
	+ $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();
	$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);

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

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

	$key = $comment_action->getKey();

	// TODO: Validate these better.

	$comment_actions[$key] = $comment_action;
	}

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

	$view->setCommentActions($comment_actions);

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

	return $view;
	}

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

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

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

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

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


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


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

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

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

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

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

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

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


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

	return $this->getController()
	->newDialog()
	->setTitle($title)
	->appendParagraph($body)
	->addCancelButton($cancel_uri);
	}


	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 buildCommentResponse($object) {
	$viewer = $this->getViewer();

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

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

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

	- $config = $this->loadDefaultEditConfiguration();
	+ $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();

	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 (array_key_exists('initialValue', $action)) {
	$field->setInitialValue($action['initialValue']);
	}

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

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

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

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

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

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

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

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

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

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

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

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

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


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


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

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

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

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

	$this->validateObject($object);

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

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

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

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

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

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

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

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


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

	$viewer = $request->getUser();
	$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));
	}

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

	$results = array();

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

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

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

	$parameter_type->setViewer($viewer);

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

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

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

	return $results;
	}


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

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

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

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

	$object = $this->newEditableObject();
	$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;
	}


	/* -( 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/query/PhabricatorEditEngineConfigurationQuery.php b/src/applications/transactions/query/PhabricatorEditEngineConfigurationQuery.php
	index b57e4b7675..d2cbc3e697 100644
	--- a/src/applications/transactions/query/PhabricatorEditEngineConfigurationQuery.php
	+++ b/src/applications/transactions/query/PhabricatorEditEngineConfigurationQuery.php
	@@ -1,260 +1,284 @@
	<?php

	final class PhabricatorEditEngineConfigurationQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $ids;
	private $phids;
	private $engineKeys;
	private $builtinKeys;
	private $identifiers;
	private $default;
	private $isEdit;
	private $disabled;
	private $ignoreDatabaseConfigurations;
	+ private $subtypes;

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

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

	public function withEngineKeys(array $engine_keys) {
	$this->engineKeys = $engine_keys;
	return $this;
	}

	public function withBuiltinKeys(array $builtin_keys) {
	$this->builtinKeys = $builtin_keys;
	return $this;
	}

	public function withIdentifiers(array $identifiers) {
	$this->identifiers = $identifiers;
	return $this;
	}

	public function withIsDefault($default) {
	$this->default = $default;
	return $this;
	}

	public function withIsEdit($edit) {
	$this->isEdit = $edit;
	return $this;
	}

	public function withIsDisabled($disabled) {
	$this->disabled = $disabled;
	return $this;
	}

	public function withIgnoreDatabaseConfigurations($ignore) {
	$this->ignoreDatabaseConfigurations = $ignore;
	return $this;
	}

	+ public function withSubtypes(array $subtypes) {
	+ $this->subtypes = $subtypes;
	+ return $this;
	+ }
	+
	public function newResultObject() {
	return new PhabricatorEditEngineConfiguration();
	}

	protected function loadPage() {
	// TODO: The logic here is a little flimsy and won't survive pagination.
	// For now, I'm just not bothering with pagination since I believe it will
	// take some time before any install manages to produce a large enough
	// number of edit forms for any particular engine for the lack of UI
	// pagination to become a problem.

	if ($this->ignoreDatabaseConfigurations) {
	$page = array();
	} else {
	$page = $this->loadStandardPage($this->newResultObject());
	}

	// Now that we've loaded the real results from the database, we're going
	// to load builtins from the edit engines and add them to the list.

	$engines = PhabricatorEditEngine::getAllEditEngines();

	if ($this->engineKeys) {
	$engines = array_select_keys($engines, $this->engineKeys);
	}

	foreach ($engines as $engine) {
	$engine->setViewer($this->getViewer());
	}

	// List all the builtins which have already been saved to the database as
	// real objects.
	$concrete = array();
	foreach ($page as $config) {
	$builtin_key = $config->getBuiltinKey();
	if ($builtin_key !== null) {
	$engine_key = $config->getEngineKey();
	$concrete[$engine_key][$builtin_key] = $config;
	}
	}

	$builtins = array();
	foreach ($engines as $engine_key => $engine) {
	$engine_builtins = $engine->getBuiltinEngineConfigurations();
	foreach ($engine_builtins as $engine_builtin) {
	$builtin_key = $engine_builtin->getBuiltinKey();
	if (isset($concrete[$engine_key][$builtin_key])) {
	continue;
	} else {
	$builtins[] = $engine_builtin;
	}
	}
	}

	foreach ($builtins as $builtin) {
	$page[] = $builtin;
	}

	// Now we have to do some extra filtering to make sure everything we're
	// about to return really satisfies the query.

	if ($this->ids !== null) {
	$ids = array_fuse($this->ids);
	foreach ($page as $key => $config) {
	if (empty($ids[$config->getID()])) {
	unset($page[$key]);
	}
	}
	}

	if ($this->phids !== null) {
	$phids = array_fuse($this->phids);
	foreach ($page as $key => $config) {
	if (empty($phids[$config->getPHID()])) {
	unset($page[$key]);
	}
	}
	}

	if ($this->builtinKeys !== null) {
	$builtin_keys = array_fuse($this->builtinKeys);
	foreach ($page as $key => $config) {
	if (empty($builtin_keys[$config->getBuiltinKey()])) {
	unset($page[$key]);
	}
	}
	}

	if ($this->default !== null) {
	foreach ($page as $key => $config) {
	if ($config->getIsDefault() != $this->default) {
	unset($page[$key]);
	}
	}
	}

	if ($this->isEdit !== null) {
	foreach ($page as $key => $config) {
	if ($config->getIsEdit() != $this->isEdit) {
	unset($page[$key]);
	}
	}
	}

	if ($this->disabled !== null) {
	foreach ($page as $key => $config) {
	if ($config->getIsDisabled() != $this->disabled) {
	unset($page[$key]);
	}
	}
	}

	if ($this->identifiers !== null) {
	$identifiers = array_fuse($this->identifiers);
	foreach ($page as $key => $config) {
	if (isset($identifiers[$config->getBuiltinKey()])) {
	continue;
	}
	if (isset($identifiers[$config->getID()])) {
	continue;
	}
	unset($page[$key]);
	}
	}

	+ if ($this->subtypes !== null) {
	+ $subtypes = array_fuse($this->subtypes);
	+ foreach ($page as $key => $config) {
	+ if (isset($subtypes[$config->getSubtype()])) {
	+ continue;
	+ }
	+
	+ unset($page[$key]);
	+ }
	+ }
	+
	return $page;
	}

	protected function willFilterPage(array $configs) {
	$engine_keys = mpull($configs, 'getEngineKey');

	$engines = id(new PhabricatorEditEngineQuery())
	->setParentQuery($this)
	->setViewer($this->getViewer())
	->withEngineKeys($engine_keys)
	->execute();
	$engines = mpull($engines, null, 'getEngineKey');

	foreach ($configs as $key => $config) {
	$engine = idx($engines, $config->getEngineKey());

	if (!$engine) {
	$this->didRejectResult($config);
	unset($configs[$key]);
	continue;
	}

	$config->attachEngine($engine);
	}

	return $configs;
	}

	protected function buildWhereClauseParts(AphrontDatabaseConnection $conn) {
	$where = parent::buildWhereClauseParts($conn);

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

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

	if ($this->engineKeys !== null) {
	$where[] = qsprintf(
	$conn,
	'engineKey IN (%Ls)',
	$this->engineKeys);
	}

	if ($this->builtinKeys !== null) {
	$where[] = qsprintf(
	$conn,
	'builtinKey IN (%Ls)',
	$this->builtinKeys);
	}

	if ($this->identifiers !== null) {
	$where[] = qsprintf(
	$conn,
	'(id IN (%Ls) OR builtinKey IN (%Ls))',
	$this->identifiers,
	$this->identifiers);
	}

	+ if ($this->subtypes !== null) {
	+ $where[] = qsprintf(
	+ $conn,
	+ 'subtype IN (%Ls)',
	+ $this->subtypes);
	+ }
	+
	return $where;
	}

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

	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Mar 17, 2:58 AM (1 d, 12 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 72244
Default Alt Text: (120 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions