No OneTemporary
Actions

Size

22 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 5d1999c2af..f1157bcb9f 100644
	--- a/src/applications/maniphest/controller/ManiphestTaskDetailController.php
	+++ b/src/applications/maniphest/controller/ManiphestTaskDetailController.php
	@@ -1,531 +1,553 @@
	<?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, $priority_color);
	$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();
	$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);
	$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]) {
	$edge_handles = $viewer->loadHandles(array_keys($edges[$edge_type]));
	$view->addProperty(
	$edge_name,
	$edge_handles->renderList());
	}
	}

	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 ($in_phids) {
	- $in_handles = $viewer->loadHandles($in_phids);
	+ if (count($in_handles)) {
	$view->addProperty(pht('Mentioned In'), $in_handles->renderList());
	}

	- if ($out_phids) {
	- $out_handles = $viewer->loadHandles($out_phids);
	+ 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/phid/handle/pool/PhabricatorHandleList.php b/src/applications/phid/handle/pool/PhabricatorHandleList.php
	index 7a8fed529f..d9a279f8ba 100644
	--- a/src/applications/phid/handle/pool/PhabricatorHandleList.php
	+++ b/src/applications/phid/handle/pool/PhabricatorHandleList.php
	@@ -1,174 +1,192 @@
	<?php

	/**
	* A list of object handles.
	*
	* This is a convenience class which behaves like an array but makes working
	* with handles more convenient, improves their caching and batching semantics,
	* and provides some utility behavior.
	*
	* Load a handle list by calling `loadHandles()` on a `$viewer`:
	*
	* $handles = $viewer->loadHandles($phids);
	*
	* This creates a handle list object, which behaves like an array of handles.
	* However, it benefits from the viewer's internal handle cache and performs
	* just-in-time bulk loading.
	*/
	final class PhabricatorHandleList
	extends Phobject
	implements
	Iterator,
	ArrayAccess,
	Countable {

	private $handlePool;
	private $phids;
	private $count;
	private $handles;
	private $cursor;
	private $map;

	public function setHandlePool(PhabricatorHandlePool $pool) {
	$this->handlePool = $pool;
	return $this;
	}

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

	private function loadHandles() {
	$this->handles = $this->handlePool->loadPHIDs($this->phids);
	}

	private function getHandle($phid) {
	if ($this->handles === null) {
	$this->loadHandles();
	}

	if (empty($this->handles[$phid])) {
	throw new Exception(
	pht(
	'Requested handle "%s" was not loaded.',
	$phid));
	}

	return $this->handles[$phid];
	}


	/**
	* Get a handle from this list if it exists.
	*
	* This has similar semantics to @{function:idx}.
	*/
	public function getHandleIfExists($phid, $default = null) {
	if ($this->handles === null) {
	$this->loadHandles();
	}

	return idx($this->handles, $phid, $default);
	}


	+ /**
	+ * Create a new list with a subset of the PHIDs in this list.
	+ */
	+ public function newSublist(array $phids) {
	+ foreach ($phids as $phid) {
	+ if (!isset($this[$phid])) {
	+ throw new Exception(
	+ pht(
	+ 'Trying to create a new sublist of an existsing handle list, '.
	+ 'but PHID "%s" does not appear in the parent list.',
	+ $phid));
	+ }
	+ }
	+
	+ return $this->handlePool->newHandleList($phids);
	+ }
	+
	+
	/* -( Rendering )---------------------------------------------------------- */


	/**
	* Return a @{class:PHUIHandleListView} which can render the handles in
	* this list.
	*/
	public function renderList() {
	return id(new PHUIHandleListView())
	->setHandleList($this);
	}


	/**
	* Return a @{class:PHUIHandleView} which can render a specific handle.
	*/
	public function renderHandle($phid) {
	if (!isset($this[$phid])) {
	throw new Exception(
	pht('Trying to render a handle which does not exist!'));
	}

	return id(new PHUIHandleView())
	->setHandleList($this)
	->setHandlePHID($phid);
	}

	/* -( Iterator )----------------------------------------------------------- */


	public function rewind() {
	$this->cursor = 0;
	}

	public function current() {
	return $this->getHandle($this->phids[$this->cursor]);
	}

	public function key() {
	return $this->phids[$this->cursor];
	}

	public function next() {
	++$this->cursor;
	}

	public function valid() {
	return ($this->cursor < $this->count);
	}


	/* -( ArrayAccess )-------------------------------------------------------- */


	public function offsetExists($offset) {
	// NOTE: We're intentionally not loading handles here so that isset()
	// checks do not trigger fetches. This gives us better bulk loading
	// behavior, particularly when invoked through methods like renderHandle().

	if ($this->map === null) {
	$this->map = array_fill_keys($this->phids, true);
	}

	return isset($this->map[$offset]);
	}

	public function offsetGet($offset) {
	if ($this->handles === null) {
	$this->loadHandles();
	}
	return $this->handles[$offset];
	}

	public function offsetSet($offset, $value) {
	$this->raiseImmutableException();
	}

	public function offsetUnset($offset) {
	$this->raiseImmutableException();
	}

	private function raiseImmutableException() {
	throw new Exception(
	pht(
	'Trying to mutate a %s, but this is not permitted; '.
	'handle lists are immutable.',
	__CLASS__));
	}


	/* -( Countable )---------------------------------------------------------- */


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

	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Jan 19, 14:38 (3 w, 2 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1125588
Default Alt Text: (22 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions