No OneTemporary
Actions

Size

73 KB

Subscribers

None

View Options

	diff --git a/src/applications/maniphest/config/PhabricatorManiphestConfigOptions.php b/src/applications/maniphest/config/PhabricatorManiphestConfigOptions.php
	index 4a1927c5a..9d927ffca 100644
	--- a/src/applications/maniphest/config/PhabricatorManiphestConfigOptions.php
	+++ b/src/applications/maniphest/config/PhabricatorManiphestConfigOptions.php
	@@ -1,417 +1,424 @@
	<?php

	final class PhabricatorManiphestConfigOptions
	extends PhabricatorApplicationConfigOptions {

	public function getName() {
	return pht('Maniphest');
	}

	public function getDescription() {
	return pht('Configure Maniphest.');
	}

	public function getIcon() {
	return 'fa-anchor';
	}

	public function getGroup() {
	return 'apps';
	}

	public function getOptions() {
	$priority_type = 'custom:ManiphestPriorityConfigOptionType';
	$priority_defaults = array(
	100 => array(
	'name' => pht('Unbreak Now!'),
	'short' => pht('Unbreak!'),
	'color' => 'pink',
	'keywords' => array('unbreak'),
	),
	90 => array(
	'name' => pht('Needs Triage'),
	'short' => pht('Triage'),
	'color' => 'violet',
	'keywords' => array('triage'),
	),
	80 => array(
	'name' => pht('High'),
	'short' => pht('High'),
	'color' => 'red',
	'keywords' => array('high'),
	),
	50 => array(
	'name' => pht('Normal'),
	'short' => pht('Normal'),
	'color' => 'orange',
	'keywords' => array('normal'),
	),
	25 => array(
	'name' => pht('Low'),
	'short' => pht('Low'),
	'color' => 'yellow',
	'keywords' => array('low'),
	),
	0 => array(
	'name' => pht('Wishlist'),
	'short' => pht('Wish'),
	'color' => 'sky',
	'keywords' => array('wish', 'wishlist'),
	),
	);

	$status_type = 'custom:ManiphestStatusConfigOptionType';
	$status_defaults = array(
	'open' => array(
	'name' => pht('Open'),
	'special' => ManiphestTaskStatus::SPECIAL_DEFAULT,
	'prefixes' => array(
	'open',
	'opens',
	'reopen',
	'reopens',
	),
	),
	'resolved' => array(
	'name' => pht('Resolved'),
	'name.full' => pht('Closed, Resolved'),
	'closed' => true,
	'special' => ManiphestTaskStatus::SPECIAL_CLOSED,
	'transaction.icon' => 'fa-check-circle',
	'prefixes' => array(
	'closed',
	'closes',
	'close',
	'fix',
	'fixes',
	'fixed',
	'resolve',
	'resolves',
	'resolved',
	),
	'suffixes' => array(
	'as resolved',
	'as fixed',
	),
	'keywords' => array('closed', 'fixed', 'resolved'),
	),
	'wontfix' => array(
	'name' => pht('Wontfix'),
	'name.full' => pht('Closed, Wontfix'),
	'transaction.icon' => 'fa-ban',
	'closed' => true,
	'prefixes' => array(
	'wontfix',
	'wontfixes',
	'wontfixed',
	),
	'suffixes' => array(
	'as wontfix',
	),
	),
	'invalid' => array(
	'name' => pht('Invalid'),
	'name.full' => pht('Closed, Invalid'),
	'transaction.icon' => 'fa-minus-circle',
	'closed' => true,
	'claim' => false,
	'prefixes' => array(
	'invalidate',
	'invalidates',
	'invalidated',
	),
	'suffixes' => array(
	'as invalid',
	),
	),
	'duplicate' => array(
	'name' => pht('Duplicate'),
	'name.full' => pht('Closed, Duplicate'),
	'transaction.icon' => 'fa-files-o',
	'special' => ManiphestTaskStatus::SPECIAL_DUPLICATE,
	'closed' => true,
	'claim' => false,
	),
	'spite' => array(
	'name' => pht('Spite'),
	'name.full' => pht('Closed, Spite'),
	'name.action' => pht('Spited'),
	'transaction.icon' => 'fa-thumbs-o-down',
	'silly' => true,
	'closed' => true,
	'prefixes' => array(
	'spite',
	'spites',
	'spited',
	),
	'suffixes' => array(
	'out of spite',
	'as spite',
	),
	),
	);

	$status_description = $this->deformat(pht(<<<EOTEXT
	Allows you to edit, add, or remove the task statuses available in Maniphest,
	like "Open", "Resolved" and "Invalid". The configuration should contain a map
	of status constants to status specifications (see defaults below for examples).

	The constant for each status should be 1-12 characters long and contain only
	lowercase letters and digits. Valid examples are "open", "closed", and
	"invalid". Users will not normally see these values.

	The keys you can provide in a specification are:

	- `name` //Required string.// Name of the status, like "Invalid".
	- `name.full` //Optional string.// Longer name, like "Closed, Invalid". This
	appears on the task detail view in the header.
	- `name.action` //Optional string.// Action name for email subjects, like
	"Marked Invalid".
	- `closed` //Optional bool.// Statuses are either "open" or "closed".
	Specifying `true` here will mark the status as closed (like "Resolved" or
	"Invalid"). By default, statuses are open.
	- `special` //Optional string.// Mark this status as special. The special
	statuses are:
	- `default` This is the default status for newly created tasks. You must
	designate one status as default, and it must be an open status.
	- `closed` This is the default status for closed tasks (for example, tasks
	closed via the "!close" action in email or via the quick close button in
	Maniphest). You must designate one status as the default closed status,
	and it must be a closed status.
	- `duplicate` This is the status used when tasks are merged into one
	another as duplicates. You must designate one status for duplicates,
	and it must be a closed status.
	- `transaction.icon` //Optional string.// Allows you to choose a different
	icon to use for this status when showing status changes in the transaction
	log. Please see UIExamples, Icons and Images for a list.
	- `transaction.color` //Optional string.// Allows you to choose a different
	color to use for this status when showing status changes in the transaction
	log.
	- `silly` //Optional bool.// Marks this status as silly, and thus wholly
	inappropriate for use by serious businesses.
	- `prefixes` //Optional list<string>.// Allows you to specify a list of
	text prefixes which will trigger a task transition into this status
	when mentioned in a commit message. For example, providing "closes" here
	will allow users to move tasks to this status by writing `Closes T123` in
	commit messages.
	- `suffixes` //Optional list<string>.// Allows you to specify a list of
	text suffixes which will trigger a task transition into this status
	when mentioned in a commit message, after a valid prefix. For example,
	providing "as invalid" here will allow users to move tasks
	to this status by writing `Closes T123 as invalid`, even if another status
	is selected by the "Closes" prefix.
	- `keywords` //Optional list<string>.// Allows you to specify a list
	of keywords which can be used with `!status` commands in email to select
	this status.
	- `disabled` //Optional bool.// Marks this status as no longer in use so
	tasks can not be created or edited to have this status. Existing tasks with
	this status will not be affected, but you can batch edit them or let them
	die out on their own.
	- `claim` //Optional bool.// By default, closing an unassigned task claims
	it. You can set this to `false` to disable this behavior for a particular
	status.
	- `locked` //Optional bool.// Lock tasks in this status, preventing users
	from commenting.

	Statuses will appear in the UI in the order specified. Note the status marked
	`special` as `duplicate` is not settable directly and will not appear in UI
	elements, and that any status marked `silly` does not appear if Phabricator
	is configured with `phabricator.serious-business` set to true.

	Examining the default configuration and examples below will probably be helpful
	in understanding these options.

	EOTEXT
	));

	$status_example = array(
	'open' => array(
	'name' => pht('Open'),
	'special' => 'default',
	),
	'closed' => array(
	'name' => pht('Closed'),
	'special' => 'closed',
	'closed' => true,
	),
	'duplicate' => array(
	'name' => pht('Duplicate'),
	'special' => 'duplicate',
	'closed' => true,
	),
	);

	$json = new PhutilJSON();
	$status_example = $json->encodeFormatted($status_example);

	// This is intentionally blank for now, until we can move more Maniphest
	// logic to custom fields.
	$default_fields = array();

	foreach ($default_fields as $key => $enabled) {
	$default_fields[$key] = array(
	'disabled' => !$enabled,
	);
	}

	$custom_field_type = 'custom:PhabricatorCustomFieldConfigOptionType';

	$fields_example = array(
	'mycompany.estimated-hours' => array(
	'name' => pht('Estimated Hours'),
	'type' => 'int',
	'caption' => pht('Estimated number of hours this will take.'),
	),
	);
	$fields_json = id(new PhutilJSON())->encodeFormatted($fields_example);

	$points_type = 'custom:ManiphestPointsConfigOptionType';

	$points_example_1 = array(
	'enabled' => true,
	'label' => pht('Story Points'),
	'action' => pht('Change Story Points'),
	);
	$points_json_1 = id(new PhutilJSON())->encodeFormatted($points_example_1);

	$points_example_2 = array(
	'enabled' => true,
	'label' => pht('Estimated Hours'),
	'action' => pht('Change Estimate'),
	);
	$points_json_2 = id(new PhutilJSON())->encodeFormatted($points_example_2);

	$points_description = $this->deformat(pht(<<<EOTEXT
	Activates a points field on tasks. You can use points for estimation or
	planning. If configured, points will appear on workboards.

	To activate points, set this value to a map with these keys:

	- `enabled` //Optional bool.// Use `true` to enable points, or
	`false` to disable them.
	- `label` //Optional string.// Label for points, like "Story Points" or
	"Estimated Hours". If omitted, points will be called "Points".
	- `action` //Optional string.// Label for the action which changes points
	in Maniphest, like "Change Estimate". If omitted, the action will
	be called "Change Points".

	See the example below for a starting point.
	EOTEXT
	));

	$subtype_type = 'custom:ManiphestSubtypesConfigOptionsType';
	$subtype_default_key = PhabricatorEditEngineSubtype::SUBTYPE_DEFAULT;
	$subtype_example = array(
	array(
	'key' => $subtype_default_key,
	'name' => pht('Task'),
	),
	array(
	'key' => 'bug',
	'name' => pht('Bug'),
	),
	array(
	'key' => 'feature',
	'name' => pht('Feature Request'),
	),
	);
	$subtype_example = id(new PhutilJSON())->encodeAsList($subtype_example);

	$subtype_default = array(
	array(
	'key' => $subtype_default_key,
	'name' => pht('Task'),
	),
	);

	$subtype_description = $this->deformat(pht(<<<EOTEXT
	Allows you to define task subtypes. Subtypes let you hide fields you don't
	need to simplify the workflows for editing tasks.

	To define subtypes, provide a list of subtypes. Each subtype should be a
	dictionary with these keys:

	- `key` //Required string.// Internal identifier for the subtype, like
	"task", "feature", or "bug".
	- `name` //Required string.// Human-readable name for this subtype, like
	"Task", "Feature Request" or "Bug Report".
	+ - `tag` //Optional string.// Tag text for this subtype.
	+ - `color` //Optional string.// Display color for this subtype.
	+ - `icon` //Optional string.// Icon for the subtype.

	Each subtype must have a unique key, and you must define a subtype with
	the key "%s", which is used as a default subtype.
	+
	+The tag text (`tag`) is used to set the text shown in the subtype tag on list
	+views and workboards. If you do not configure it, the default subtype will have
	+no subtype tag and other subtypes will use their name as tag text.
	EOTEXT
	,
	$subtype_default_key));


	return array(
	$this->newOption('maniphest.custom-field-definitions', 'wild', array())
	->setSummary(pht('Custom Maniphest fields.'))
	->setDescription(
	pht(
	'Array of custom fields for Maniphest tasks. For details on '.
	'adding custom fields to Maniphest, see "Configuring Custom '.
	'Fields" in the documentation.'))
	->addExample($fields_json, pht('Valid setting')),
	$this->newOption('maniphest.fields', $custom_field_type, $default_fields)
	->setCustomData(id(new ManiphestTask())->getCustomFieldBaseClass())
	->setDescription(pht('Select and reorder task fields.')),
	$this->newOption(
	'maniphest.priorities',
	$priority_type,
	$priority_defaults)
	->setSummary(pht('Configure Maniphest priority names.'))
	->setDescription(
	pht(
	'Allows you to edit or override the default priorities available '.
	'in Maniphest, like "High", "Normal" and "Low". The configuration '.
	'should contain a map of priority constants to priority '.
	'specifications (see defaults below for examples).'.
	"\n\n".
	'The keys you can define for a priority are:'.
	"\n\n".
	' - `name` Name of the priority.'."\n".
	' - `short` Alternate shorter name, used in UIs where there is '.
	' not much space available.'."\n".
	' - `color` A color for this priority, like "red" or "blue".'.
	' - `keywords` An optional list of keywords which can '.
	' be used to select this priority when using `!priority` '.
	' commands in email.'."\n".
	' - `disabled` Optional boolean to prevent users from choosing '.
	' this priority when creating or editing tasks. Existing '.
	' tasks will be unaffected, and can be batch edited to a '.
	' different priority or left to eventually die out.'.
	"\n\n".
	'You can choose which priority is the default for newly created '.
	'tasks with `%s`.',
	'maniphest.default-priority')),
	$this->newOption('maniphest.statuses', $status_type, $status_defaults)
	->setSummary(pht('Configure Maniphest task statuses.'))
	->setDescription($status_description)
	->addExample($status_example, pht('Minimal Valid Config')),
	$this->newOption('maniphest.default-priority', 'int', 90)
	->setSummary(pht('Default task priority for create flows.'))
	->setDescription(
	pht(
	'Choose a default priority for newly created tasks. You can '.
	'review and adjust available priorities by using the '.
	'%s configuration option. The default value (`90`) '.
	'corresponds to the default "Needs Triage" priority.',
	'maniphest.priorities')),
	$this->newOption(
	'metamta.maniphest.subject-prefix',
	'string',
	'[Maniphest]')
	->setDescription(pht('Subject prefix for Maniphest mail.')),
	$this->newOption('maniphest.points', $points_type, array())
	->setSummary(pht('Configure point values for tasks.'))
	->setDescription($points_description)
	->addExample($points_json_1, pht('Points Config'))
	->addExample($points_json_2, pht('Hours Config')),
	$this->newOption('maniphest.subtypes', $subtype_type, $subtype_default)
	->setSummary(pht('Define task subtypes.'))
	->setDescription($subtype_description)
	->addExample($subtype_example, pht('Simple Subtypes')),
	);
	}

	}
	diff --git a/src/applications/maniphest/controller/ManiphestTaskDetailController.php b/src/applications/maniphest/controller/ManiphestTaskDetailController.php
	index 7859599a2..92fe703f9 100644
	--- a/src/applications/maniphest/controller/ManiphestTaskDetailController.php
	+++ b/src/applications/maniphest/controller/ManiphestTaskDetailController.php
	@@ -1,564 +1,570 @@
	<?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)
	->setColor(PHUITagView::COLOR_BLUE)
	->setType(PHUITagView::TYPE_SHADE);

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

	+ $subtype = $task->newSubtypeObject();
	+ if ($subtype && $subtype->hasTagView()) {
	+ $subtype_tag = $subtype->newTagView();
	+ $view->addTag($subtype_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);

	$can_interact = PhabricatorPolicyFilter::canInteract($viewer, $task);

	// We expect a policy dialog if you can't edit the task, and expect a
	// lock override dialog if you can't interact with it.
	$workflow_edit = (!$can_edit \|\| !$can_interact);

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

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

	$can_reassign = $edit_engine->hasEditAccessToTransaction(
	ManiphestTaskOwnerTransaction::TRANSACTIONTYPE);

	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/maniphest/storage/ManiphestTask.php b/src/applications/maniphest/storage/ManiphestTask.php
	index 16937da2f..7cf9d3353 100644
	--- a/src/applications/maniphest/storage/ManiphestTask.php
	+++ b/src/applications/maniphest/storage/ManiphestTask.php
	@@ -1,590 +1,595 @@
	<?php

	final class ManiphestTask extends ManiphestDAO
	implements
	PhabricatorSubscribableInterface,
	PhabricatorMarkupInterface,
	PhabricatorPolicyInterface,
	PhabricatorTokenReceiverInterface,
	PhabricatorFlaggableInterface,
	PhabricatorMentionableInterface,
	PhrequentTrackableInterface,
	PhabricatorCustomFieldInterface,
	PhabricatorDestructibleInterface,
	PhabricatorApplicationTransactionInterface,
	PhabricatorProjectInterface,
	PhabricatorSpacesInterface,
	PhabricatorConduitResultInterface,
	PhabricatorFulltextInterface,
	DoorkeeperBridgedObjectInterface,
	PhabricatorEditEngineSubtypeInterface,
	PhabricatorEditEngineLockableInterface {

	const MARKUP_FIELD_DESCRIPTION = 'markup:desc';

	protected $authorPHID;
	protected $ownerPHID;

	protected $status;
	protected $priority;
	protected $subpriority = 0;

	protected $title = '';
	protected $originalTitle = '';
	protected $description = '';
	protected $originalEmailSource;
	protected $mailKey;
	protected $viewPolicy = PhabricatorPolicies::POLICY_USER;
	protected $editPolicy = PhabricatorPolicies::POLICY_USER;

	protected $ownerOrdering;
	protected $spacePHID;
	protected $bridgedObjectPHID;
	protected $properties = array();
	protected $points;
	protected $subtype;

	private $subscriberPHIDs = self::ATTACHABLE;
	private $groupByProjectPHID = self::ATTACHABLE;
	private $customFields = self::ATTACHABLE;
	private $edgeProjectPHIDs = self::ATTACHABLE;
	private $bridgedObject = self::ATTACHABLE;

	public static function initializeNewTask(PhabricatorUser $actor) {
	$app = id(new PhabricatorApplicationQuery())
	->setViewer($actor)
	->withClasses(array('PhabricatorManiphestApplication'))
	->executeOne();

	$view_policy = $app->getPolicy(ManiphestDefaultViewCapability::CAPABILITY);
	$edit_policy = $app->getPolicy(ManiphestDefaultEditCapability::CAPABILITY);

	return id(new ManiphestTask())
	->setStatus(ManiphestTaskStatus::getDefaultStatus())
	->setPriority(ManiphestTaskPriority::getDefaultPriority())
	->setAuthorPHID($actor->getPHID())
	->setViewPolicy($view_policy)
	->setEditPolicy($edit_policy)
	->setSpacePHID($actor->getDefaultSpacePHID())
	->setSubtype(PhabricatorEditEngineSubtype::SUBTYPE_DEFAULT)
	->attachProjectPHIDs(array())
	->attachSubscriberPHIDs(array());
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_SERIALIZATION => array(
	'properties' => self::SERIALIZATION_JSON,
	),
	self::CONFIG_COLUMN_SCHEMA => array(
	'ownerPHID' => 'phid?',
	'status' => 'text12',
	'priority' => 'uint32',
	'title' => 'sort',
	'originalTitle' => 'text',
	'description' => 'text',
	'mailKey' => 'bytes20',
	'ownerOrdering' => 'text64?',
	'originalEmailSource' => 'text255?',
	'subpriority' => 'double',
	'points' => 'double?',
	'bridgedObjectPHID' => 'phid?',
	'subtype' => 'text64',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_phid' => null,
	'phid' => array(
	'columns' => array('phid'),
	'unique' => true,
	),
	'priority' => array(
	'columns' => array('priority', 'status'),
	),
	'status' => array(
	'columns' => array('status'),
	),
	'ownerPHID' => array(
	'columns' => array('ownerPHID', 'status'),
	),
	'authorPHID' => array(
	'columns' => array('authorPHID', 'status'),
	),
	'ownerOrdering' => array(
	'columns' => array('ownerOrdering'),
	),
	'priority_2' => array(
	'columns' => array('priority', 'subpriority'),
	),
	'key_dateCreated' => array(
	'columns' => array('dateCreated'),
	),
	'key_dateModified' => array(
	'columns' => array('dateModified'),
	),
	'key_title' => array(
	'columns' => array('title(64)'),
	),
	'key_bridgedobject' => array(
	'columns' => array('bridgedObjectPHID'),
	'unique' => true,
	),
	'key_subtype' => array(
	'columns' => array('subtype'),
	),
	),
	) + parent::getConfiguration();
	}

	public function loadDependsOnTaskPHIDs() {
	return PhabricatorEdgeQuery::loadDestinationPHIDs(
	$this->getPHID(),
	ManiphestTaskDependsOnTaskEdgeType::EDGECONST);
	}

	public function loadDependedOnByTaskPHIDs() {
	return PhabricatorEdgeQuery::loadDestinationPHIDs(
	$this->getPHID(),
	ManiphestTaskDependedOnByTaskEdgeType::EDGECONST);
	}

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

	public function getSubscriberPHIDs() {
	return $this->assertAttached($this->subscriberPHIDs);
	}

	public function getProjectPHIDs() {
	return $this->assertAttached($this->edgeProjectPHIDs);
	}

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

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

	public function setOwnerPHID($phid) {
	$this->ownerPHID = nonempty($phid, null);
	return $this;
	}

	public function setTitle($title) {
	$this->title = $title;
	if (!$this->getID()) {
	$this->originalTitle = $title;
	}
	return $this;
	}

	public function getMonogram() {
	return 'T'.$this->getID();
	}

	public function getURI() {
	return '/'.$this->getMonogram();
	}

	public function attachGroupByProjectPHID($phid) {
	$this->groupByProjectPHID = $phid;
	return $this;
	}

	public function getGroupByProjectPHID() {
	return $this->assertAttached($this->groupByProjectPHID);
	}

	public function save() {
	if (!$this->mailKey) {
	$this->mailKey = Filesystem::readRandomCharacters(20);
	}

	$result = parent::save();

	return $result;
	}

	public function isClosed() {
	return ManiphestTaskStatus::isClosedStatus($this->getStatus());
	}

	public function isLocked() {
	return ManiphestTaskStatus::isLockedStatus($this->getStatus());
	}

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

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

	public function getCoverImageFilePHID() {
	return idx($this->properties, 'cover.filePHID');
	}

	public function getCoverImageThumbnailPHID() {
	return idx($this->properties, 'cover.thumbnailPHID');
	}

	public function getWorkboardOrderVectors() {
	return array(
	PhabricatorProjectColumn::ORDER_PRIORITY => array(
	(int)-$this->getPriority(),
	(double)-$this->getSubpriority(),
	(int)-$this->getID(),
	),
	);
	}

	private function comparePriorityTo(ManiphestTask $other) {
	$upri = $this->getPriority();
	$vpri = $other->getPriority();

	if ($upri != $vpri) {
	return ($upri - $vpri);
	}

	$usub = $this->getSubpriority();
	$vsub = $other->getSubpriority();

	if ($usub != $vsub) {
	return ($usub - $vsub);
	}

	$uid = $this->getID();
	$vid = $other->getID();

	if ($uid != $vid) {
	return ($uid - $vid);
	}

	return 0;
	}

	public function isLowerPriorityThan(ManiphestTask $other) {
	return ($this->comparePriorityTo($other) < 0);
	}

	public function isHigherPriorityThan(ManiphestTask $other) {
	return ($this->comparePriorityTo($other) > 0);
	}

	public function getWorkboardProperties() {
	return array(
	'status' => $this->getStatus(),
	'points' => (double)$this->getPoints(),
	);
	}


	/* -( PhabricatorSubscribableInterface )----------------------------------- */


	public function isAutomaticallySubscribed($phid) {
	return ($phid == $this->getOwnerPHID());
	}


	/* -( Markup Interface )--------------------------------------------------- */


	/**
	* @task markup
	*/
	public function getMarkupFieldKey($field) {
	$content = $this->getMarkupText($field);
	return PhabricatorMarkupEngine::digestRemarkupContent($this, $content);
	}


	/**
	* @task markup
	*/
	public function getMarkupText($field) {
	return $this->getDescription();
	}


	/**
	* @task markup
	*/
	public function newMarkupEngine($field) {
	return PhabricatorMarkupEngine::newManiphestMarkupEngine();
	}


	/**
	* @task markup
	*/
	public function didMarkupText(
	$field,
	$output,
	PhutilMarkupEngine $engine) {
	return $output;
	}


	/**
	* @task markup
	*/
	public function shouldUseMarkupCache($field) {
	return (bool)$this->getID();
	}


	/* -( Policy Interface )--------------------------------------------------- */


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

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return $this->getViewPolicy();
	case PhabricatorPolicyCapability::CAN_INTERACT:
	if ($this->isLocked()) {
	return PhabricatorPolicies::POLICY_NOONE;
	} else {
	return $this->getViewPolicy();
	}
	case PhabricatorPolicyCapability::CAN_EDIT:
	return $this->getEditPolicy();
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $user) {
	// The owner of a task can always view and edit it.
	$owner_phid = $this->getOwnerPHID();
	if ($owner_phid) {
	$user_phid = $user->getPHID();
	if ($user_phid == $owner_phid) {
	return true;
	}
	}

	return false;
	}

	public function describeAutomaticCapability($capability) {
	return pht('The owner of a task can always view and edit it.');
	}


	/* -( PhabricatorTokenReceiverInterface )---------------------------------- */


	public function getUsersToNotifyOfTokenGiven() {
	// Sort of ambiguous who this was intended for; just let them both know.
	return array_filter(
	array_unique(
	array(
	$this->getAuthorPHID(),
	$this->getOwnerPHID(),
	)));
	}


	/* -( PhabricatorCustomFieldInterface )------------------------------------ */


	public function getCustomFieldSpecificationForRole($role) {
	return PhabricatorEnv::getEnvConfig('maniphest.fields');
	}

	public function getCustomFieldBaseClass() {
	return 'ManiphestCustomField';
	}

	public function getCustomFields() {
	return $this->assertAttached($this->customFields);
	}

	public function attachCustomFields(PhabricatorCustomFieldAttachment $fields) {
	$this->customFields = $fields;
	return $this;
	}


	/* -( PhabricatorDestructibleInterface )----------------------------------- */


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

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


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


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

	public function getApplicationTransactionObject() {
	return $this;
	}

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

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

	return $timeline;
	}


	/* -( PhabricatorSpacesInterface )----------------------------------------- */


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


	/* -( PhabricatorConduitResultInterface )---------------------------------- */


	public function getFieldSpecificationsForConduit() {
	return array(
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('title')
	->setType('string')
	->setDescription(pht('The title of the task.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('description')
	->setType('remarkup')
	->setDescription(pht('The task description.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('authorPHID')
	->setType('phid')
	->setDescription(pht('Original task author.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('ownerPHID')
	->setType('phid?')
	->setDescription(pht('Current task owner, if task is assigned.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('status')
	->setType('map<string, wild>')
	->setDescription(pht('Information about task status.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('priority')
	->setType('map<string, wild>')
	->setDescription(pht('Information about task priority.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('points')
	->setType('points')
	->setDescription(pht('Point value of the task.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('subtype')
	->setType('string')
	->setDescription(pht('Subtype of the task.')),
	);
	}

	public function getFieldValuesForConduit() {
	$status_value = $this->getStatus();
	$status_info = array(
	'value' => $status_value,
	'name' => ManiphestTaskStatus::getTaskStatusName($status_value),
	'color' => ManiphestTaskStatus::getStatusColor($status_value),
	);

	$priority_value = (int)$this->getPriority();
	$priority_info = array(
	'value' => $priority_value,
	'subpriority' => (double)$this->getSubpriority(),
	'name' => ManiphestTaskPriority::getTaskPriorityName($priority_value),
	'color' => ManiphestTaskPriority::getTaskPriorityColor($priority_value),
	);

	return array(
	'name' => $this->getTitle(),
	'description' => array(
	'raw' => $this->getDescription(),
	),
	'authorPHID' => $this->getAuthorPHID(),
	'ownerPHID' => $this->getOwnerPHID(),
	'status' => $status_info,
	'priority' => $priority_info,
	'points' => $this->getPoints(),
	'subtype' => $this->getSubtype(),
	);
	}

	public function getConduitSearchAttachments() {
	return array(
	id(new PhabricatorBoardColumnsSearchEngineAttachment())
	->setAttachmentKey('columns'),
	);
	}

	+ public function newSubtypeObject() {
	+ $subtype_key = $this->getEditEngineSubtype();
	+ $subtype_map = $this->newEditEngineSubtypeMap();
	+ return idx($subtype_map, $subtype_key);
	+ }

	/* -( PhabricatorFulltextInterface )--------------------------------------- */


	public function newFulltextEngine() {
	return new ManiphestTaskFulltextEngine();
	}


	/* -( DoorkeeperBridgedObjectInterface )----------------------------------- */


	public function getBridgedObject() {
	return $this->assertAttached($this->bridgedObject);
	}

	public function attachBridgedObject(
	DoorkeeperExternalObject $object = null) {
	$this->bridgedObject = $object;
	return $this;
	}


	/* -( PhabricatorEditEngineSubtypeInterface )------------------------------ */


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

	public function setEditEngineSubtype($value) {
	return $this->setSubtype($value);
	}

	public function newEditEngineSubtypeMap() {
	$config = PhabricatorEnv::getEnvConfig('maniphest.subtypes');
	return PhabricatorEditEngineSubtype::newSubtypeMap($config);
	}


	/* -( PhabricatorEditEngineLockableInterface )----------------------------- */


	public function newEditEngineLock() {
	return new ManiphestTaskEditEngineLock();
	}

	}
	diff --git a/src/applications/maniphest/storage/ManiphestTransaction.php b/src/applications/maniphest/storage/ManiphestTransaction.php
	index 0d27ddc5d..e2739c1d0 100644
	--- a/src/applications/maniphest/storage/ManiphestTransaction.php
	+++ b/src/applications/maniphest/storage/ManiphestTransaction.php
	@@ -1,214 +1,224 @@
	<?php

	final class ManiphestTransaction
	extends PhabricatorModularTransaction {

	const MAILTAG_STATUS = 'maniphest-status';
	const MAILTAG_OWNER = 'maniphest-owner';
	const MAILTAG_PRIORITY = 'maniphest-priority';
	const MAILTAG_CC = 'maniphest-cc';
	const MAILTAG_PROJECTS = 'maniphest-projects';
	const MAILTAG_COMMENT = 'maniphest-comment';
	const MAILTAG_COLUMN = 'maniphest-column';
	const MAILTAG_UNBLOCK = 'maniphest-unblock';
	const MAILTAG_OTHER = 'maniphest-other';


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

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

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

	public function getBaseTransactionClass() {
	return 'ManiphestTaskTransactionType';
	}

	public function shouldGenerateOldValue() {
	switch ($this->getTransactionType()) {
	case ManiphestTaskEdgeTransaction::TRANSACTIONTYPE:
	case ManiphestTaskUnblockTransaction::TRANSACTIONTYPE:
	return false;
	}

	return parent::shouldGenerateOldValue();
	}

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

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

	switch ($this->getTransactionType()) {
	case ManiphestTaskOwnerTransaction::TRANSACTIONTYPE:
	if ($new) {
	$phids[] = $new;
	}

	if ($old) {
	$phids[] = $old;
	}
	break;
	case ManiphestTaskMergedIntoTransaction::TRANSACTIONTYPE:
	$phids[] = $new;
	break;
	case ManiphestTaskMergedFromTransaction::TRANSACTIONTYPE:
	$phids = array_merge($phids, $new);
	break;
	case ManiphestTaskEdgeTransaction::TRANSACTIONTYPE:
	$phids = array_mergev(
	array(
	$phids,
	array_keys(nonempty($old, array())),
	array_keys(nonempty($new, array())),
	));
	break;
	case ManiphestTaskAttachTransaction::TRANSACTIONTYPE:
	$old = nonempty($old, array());
	$new = nonempty($new, array());
	$phids = array_mergev(
	array(
	$phids,
	array_keys(idx($new, 'FILE', array())),
	array_keys(idx($old, 'FILE', array())),
	));
	break;
	case ManiphestTaskUnblockTransaction::TRANSACTIONTYPE:
	foreach (array_keys($new) as $phid) {
	$phids[] = $phid;
	}
	break;
	case ManiphestTaskStatusTransaction::TRANSACTIONTYPE:
	$commit_phid = $this->getMetadataValue('commitPHID');
	if ($commit_phid) {
	$phids[] = $commit_phid;
	}
	break;
	}

	return $phids;
	}

	public function getActionName() {
	$old = $this->getOldValue();
	$new = $this->getNewValue();
	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COLUMNS:
	return pht('Changed Project Column');
	}

	return parent::getActionName();
	}

	public function getIcon() {
	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COLUMNS:
	return 'fa-columns';
	}

	return parent::getIcon();
	}


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

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

	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_SUBTYPE:
	return pht(
	'%s changed the subtype of this task from "%s" to "%s".',
	$this->renderHandleLink($author_phid),
	$this->renderSubtypeName($old),
	$this->renderSubtypeName($new));
	break;
	}

	return parent::getTitle();
	}

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

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

	switch ($this->getTransactionType()) {
	case PhabricatorTransactions::TYPE_SUBTYPE:
	return pht(
	'%s changed the subtype of %s from "%s" to "%s".',
	$this->renderHandleLink($author_phid),
	$this->renderHandleLink($object_phid),
	$this->renderSubtypeName($old),
	$this->renderSubtypeName($new));
	}

	return parent::getTitleForFeed();
	}

	public function getMailTags() {
	$tags = array();
	switch ($this->getTransactionType()) {
	case ManiphestTaskMergedIntoTransaction::TRANSACTIONTYPE:
	case ManiphestTaskStatusTransaction::TRANSACTIONTYPE:
	$tags[] = self::MAILTAG_STATUS;
	break;
	case ManiphestTaskOwnerTransaction::TRANSACTIONTYPE:
	$tags[] = self::MAILTAG_OWNER;
	break;
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	$tags[] = self::MAILTAG_CC;
	break;
	case PhabricatorTransactions::TYPE_EDGE:
	switch ($this->getMetadataValue('edge:type')) {
	case PhabricatorProjectObjectHasProjectEdgeType::EDGECONST:
	$tags[] = self::MAILTAG_PROJECTS;
	break;
	default:
	$tags[] = self::MAILTAG_OTHER;
	break;
	}
	break;
	case ManiphestTaskPriorityTransaction::TRANSACTIONTYPE:
	$tags[] = self::MAILTAG_PRIORITY;
	break;
	case ManiphestTaskUnblockTransaction::TRANSACTIONTYPE:
	$tags[] = self::MAILTAG_UNBLOCK;
	break;
	case PhabricatorTransactions::TYPE_COLUMNS:
	$tags[] = self::MAILTAG_COLUMN;
	break;
	case PhabricatorTransactions::TYPE_COMMENT:
	$tags[] = self::MAILTAG_COMMENT;
	break;
	default:
	$tags[] = self::MAILTAG_OTHER;
	break;
	}
	return $tags;
	}

	public function getNoEffectDescription() {
	switch ($this->getTransactionType()) {
	case ManiphestTaskStatusTransaction::TRANSACTIONTYPE:
	return pht('The task already has the selected status.');
	case ManiphestTaskOwnerTransaction::TRANSACTIONTYPE:
	return pht('The task already has the selected owner.');
	case ManiphestTaskPriorityTransaction::TRANSACTIONTYPE:
	return pht('The task already has the selected priority.');
	}

	return parent::getNoEffectDescription();
	}

	+ public function renderSubtypeName($value) {
	+ $object = $this->getObject();
	+ $map = $object->newEditEngineSubtypeMap();
	+ if (!isset($map[$value])) {
	+ return $value;
	+ }
	+
	+ return $map[$value]->getName();
	+ }
	+
	}
	diff --git a/src/applications/maniphest/typeahead/ManiphestTaskSubtypeDatasource.php b/src/applications/maniphest/typeahead/ManiphestTaskSubtypeDatasource.php
	index 2678e946b..c061c694e 100644
	--- a/src/applications/maniphest/typeahead/ManiphestTaskSubtypeDatasource.php
	+++ b/src/applications/maniphest/typeahead/ManiphestTaskSubtypeDatasource.php
	@@ -1,44 +1,45 @@
	<?php

	final class ManiphestTaskSubtypeDatasource
	extends PhabricatorTypeaheadDatasource {

	public function getBrowseTitle() {
	return pht('Browse Subtypes');
	}

	public function getPlaceholderText() {
	return pht('Type a task subtype name...');
	}

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

	public function loadResults() {
	$results = $this->buildResults();
	return $this->filterResultsAgainstTokens($results);
	}

	protected function renderSpecialTokens(array $values) {
	return $this->renderTokensFromResults($this->buildResults(), $values);
	}

	private function buildResults() {
	$results = array();

	$subtype_map = id(new ManiphestTask())->newEditEngineSubtypeMap();
	foreach ($subtype_map as $key => $subtype) {

	$result = id(new PhabricatorTypeaheadResult())
	->setIcon($subtype->getIcon())
	+ ->setColor($subtype->getColor())
	->setPHID($key)
	->setName($subtype->getName());

	$results[$key] = $result;
	}

	return $results;
	}

	}
	diff --git a/src/applications/maniphest/view/ManiphestTaskListView.php b/src/applications/maniphest/view/ManiphestTaskListView.php
	index 6f714d0c5..de6b386ac 100644
	--- a/src/applications/maniphest/view/ManiphestTaskListView.php
	+++ b/src/applications/maniphest/view/ManiphestTaskListView.php
	@@ -1,157 +1,167 @@
	<?php

	final class ManiphestTaskListView extends ManiphestView {

	private $tasks;
	private $handles;
	private $showBatchControls;
	private $showSubpriorityControls;
	private $noDataString;

	public function setTasks(array $tasks) {
	assert_instances_of($tasks, 'ManiphestTask');
	$this->tasks = $tasks;
	return $this;
	}

	public function setHandles(array $handles) {
	assert_instances_of($handles, 'PhabricatorObjectHandle');
	$this->handles = $handles;
	return $this;
	}

	public function setShowBatchControls($show_batch_controls) {
	$this->showBatchControls = $show_batch_controls;
	return $this;
	}

	public function setShowSubpriorityControls($show_subpriority_controls) {
	$this->showSubpriorityControls = $show_subpriority_controls;
	return $this;
	}

	public function setNoDataString($text) {
	$this->noDataString = $text;
	return $this;
	}

	public function render() {
	$handles = $this->handles;

	require_celerity_resource('maniphest-task-summary-css');

	$list = new PHUIObjectItemListView();

	if ($this->noDataString) {
	$list->setNoDataString($this->noDataString);
	} else {
	$list->setNoDataString(pht('No tasks.'));
	}

	$status_map = ManiphestTaskStatus::getTaskStatusMap();
	$color_map = ManiphestTaskPriority::getColorMap();
	$priority_map = ManiphestTaskPriority::getTaskPriorityMap();

	if ($this->showBatchControls) {
	Javelin::initBehavior('maniphest-list-editor');
	}

	+ $subtype_map = id(new ManiphestTask())
	+ ->newEditEngineSubtypeMap();
	+
	foreach ($this->tasks as $task) {
	$item = id(new PHUIObjectItemView())
	->setUser($this->getUser())
	->setObject($task)
	->setObjectName('T'.$task->getID())
	->setHeader($task->getTitle())
	->setHref('/T'.$task->getID());

	if ($task->getOwnerPHID()) {
	$owner = $handles[$task->getOwnerPHID()];
	$item->addByline(pht('Assigned: %s', $owner->renderLink()));
	}

	$status = $task->getStatus();
	$pri = idx($priority_map, $task->getPriority());
	$status_name = idx($status_map, $task->getStatus());
	$tooltip = pht('%s, %s', $status_name, $pri);

	$icon = ManiphestTaskStatus::getStatusIcon($task->getStatus());
	$color = idx($color_map, $task->getPriority(), 'grey');
	if ($task->isClosed()) {
	$item->setDisabled(true);
	$color = 'grey';
	}

	$item->setStatusIcon($icon.' '.$color, $tooltip);

	$item->addIcon(
	'none',
	phabricator_datetime($task->getDateModified(), $this->getUser()));

	if ($this->showSubpriorityControls) {
	$item->setGrippable(true);
	}
	if ($this->showSubpriorityControls \|\| $this->showBatchControls) {
	$item->addSigil('maniphest-task');
	}

	+ $subtype = $task->newSubtypeObject();
	+ if ($subtype && $subtype->hasTagView()) {
	+ $subtype_tag = $subtype->newTagView()
	+ ->setSlimShady(true);
	+ $item->addAttribute($subtype_tag);
	+ }
	+
	$project_handles = array_select_keys(
	$handles,
	array_reverse($task->getProjectPHIDs()));

	$item->addAttribute(
	id(new PHUIHandleTagListView())
	->setLimit(4)
	->setNoDataString(pht('No Projects'))
	->setSlim(true)
	->setHandles($project_handles));

	$item->setMetadata(
	array(
	'taskID' => $task->getID(),
	));

	if ($this->showBatchControls) {
	$href = new PhutilURI('/maniphest/task/edit/'.$task->getID().'/');
	if (!$this->showSubpriorityControls) {
	$href->setQueryParam('ungrippable', 'true');
	}
	$item->addAction(
	id(new PHUIListItemView())
	->setIcon('fa-pencil')
	->addSigil('maniphest-edit-task')
	->setHref($href));
	}

	$list->addItem($item);
	}

	return $list;
	}

	public static function loadTaskHandles(
	PhabricatorUser $viewer,
	array $tasks) {
	assert_instances_of($tasks, 'ManiphestTask');

	$phids = array();
	foreach ($tasks as $task) {
	$assigned_phid = $task->getOwnerPHID();
	if ($assigned_phid) {
	$phids[] = $assigned_phid;
	}
	foreach ($task->getProjectPHIDs() as $project_phid) {
	$phids[] = $project_phid;
	}
	}

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

	return id(new PhabricatorHandleQuery())
	->setViewer($viewer)
	->withPHIDs($phids)
	->execute();
	}

	}
	diff --git a/src/applications/maniphest/xaction/ManiphestTaskTransactionType.php b/src/applications/maniphest/xaction/ManiphestTaskTransactionType.php
	index 699ef1163..c59de163c 100644
	--- a/src/applications/maniphest/xaction/ManiphestTaskTransactionType.php
	+++ b/src/applications/maniphest/xaction/ManiphestTaskTransactionType.php
	@@ -1,16 +1,6 @@
	<?php

	abstract class ManiphestTaskTransactionType
	extends PhabricatorModularTransactionType {

	- public function renderSubtypeName($value) {
	- $object = $this->getObject();
	- $map = $object->newEditEngineSubtypeMap();
	- if (!isset($map[$value])) {
	- return $value;
	- }
	-
	- return $map[$value]->getName();
	- }
	-
	}
	diff --git a/src/applications/project/view/ProjectBoardTaskCard.php b/src/applications/project/view/ProjectBoardTaskCard.php
	index 100fee20b..1a6807ec4 100644
	--- a/src/applications/project/view/ProjectBoardTaskCard.php
	+++ b/src/applications/project/view/ProjectBoardTaskCard.php
	@@ -1,143 +1,150 @@
	<?php

	final class ProjectBoardTaskCard extends Phobject {

	private $viewer;
	private $projectHandles;
	private $task;
	private $owner;
	private $canEdit;
	private $coverImageFile;

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

	public function setProjectHandles(array $handles) {
	$this->projectHandles = $handles;
	return $this;
	}

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

	public function setCoverImageFile(PhabricatorFile $cover_image_file) {
	$this->coverImageFile = $cover_image_file;
	return $this;
	}

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

	public function setTask(ManiphestTask $task) {
	$this->task = $task;
	return $this;
	}
	public function getTask() {
	return $this->task;
	}

	public function setOwner(PhabricatorObjectHandle $owner = null) {
	$this->owner = $owner;
	return $this;
	}
	public function getOwner() {
	return $this->owner;
	}

	public function setCanEdit($can_edit) {
	$this->canEdit = $can_edit;
	return $this;
	}

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

	public function getItem() {
	$task = $this->getTask();
	$owner = $this->getOwner();
	$can_edit = $this->getCanEdit();
	$viewer = $this->getViewer();

	$color_map = ManiphestTaskPriority::getColorMap();
	$bar_color = idx($color_map, $task->getPriority(), 'grey');

	$card = id(new PHUIObjectItemView())
	->setObject($task)
	->setUser($viewer)
	->setObjectName('T'.$task->getID())
	->setHeader($task->getTitle())
	->setGrippable($can_edit)
	->setHref('/T'.$task->getID())
	->addSigil('project-card')
	->setDisabled($task->isClosed())
	->addAction(
	id(new PHUIListItemView())
	->setName(pht('Edit'))
	->setIcon('fa-pencil')
	->addSigil('edit-project-card')
	->setHref('/maniphest/task/edit/'.$task->getID().'/'))
	->setBarColor($bar_color);

	if ($owner) {
	$card->addHandleIcon($owner, $owner->getName());
	}

	$cover_file = $this->getCoverImageFile();
	if ($cover_file) {
	$card->setCoverImage($cover_file->getBestURI());
	}

	if (ManiphestTaskPoints::getIsEnabled()) {
	$points = $task->getPoints();
	if ($points !== null) {
	$points_tag = id(new PHUITagView())
	->setType(PHUITagView::TYPE_SHADE)
	->setColor(PHUITagView::COLOR_GREY)
	->setSlimShady(true)
	->setName($points)
	->addClass('phui-workcard-points');
	$card->addAttribute($points_tag);
	}
	}

	+ $subtype = $task->newSubtypeObject();
	+ if ($subtype && $subtype->hasTagView()) {
	+ $subtype_tag = $subtype->newTagView()
	+ ->setSlimShady(true);
	+ $card->addAttribute($subtype_tag);
	+ }
	+
	if ($task->isClosed()) {
	$icon = ManiphestTaskStatus::getStatusIcon($task->getStatus());
	$icon = id(new PHUIIconView())
	->setIcon($icon.' grey');
	$card->addAttribute($icon);
	$card->setBarColor('grey');
	}

	$project_handles = $this->getProjectHandles();

	// Remove any archived projects from the list.
	if ($project_handles) {
	foreach ($project_handles as $key => $handle) {
	if ($handle->getStatus() == PhabricatorObjectHandle::STATUS_CLOSED) {
	unset($project_handles[$key]);
	}
	}
	}

	if ($project_handles) {
	$project_handles = array_reverse($project_handles);
	$tag_list = id(new PHUIHandleTagListView())
	->setSlim(true)
	->setHandles($project_handles);
	$card->addAttribute($tag_list);
	}

	$card->addClass('phui-workcard');

	return $card;
	}

	}
	diff --git a/src/applications/transactions/editengine/PhabricatorEditEngineSubtype.php b/src/applications/transactions/editengine/PhabricatorEditEngineSubtype.php
	index ff14ae239..df367955a 100644
	--- a/src/applications/transactions/editengine/PhabricatorEditEngineSubtype.php
	+++ b/src/applications/transactions/editengine/PhabricatorEditEngineSubtype.php
	@@ -1,124 +1,188 @@
	<?php


	final class PhabricatorEditEngineSubtype
	extends Phobject {

	const SUBTYPE_DEFAULT = 'default';

	private $key;
	private $name;
	+ private $icon;
	+ private $tagText;
	+ private $color;

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

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

	public function setName($name) {
	$this->name = $name;
	return $this;
	}

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

	+ public function setIcon($icon) {
	+ $this->icon = $icon;
	+ return $this;
	+ }
	+
	public function getIcon() {
	- return 'fa-drivers-license-o';
	+ return $this->icon;
	+ }
	+
	+ public function setTagText($text) {
	+ $this->tagText = $text;
	+ return $this;
	+ }
	+
	+ public function getTagText() {
	+ return $this->tagText;
	+ }
	+
	+ public function setColor($color) {
	+ $this->color = $color;
	+ return $this;
	+ }
	+
	+ public function getColor() {
	+ return $this->color;
	+ }
	+
	+ public function hasTagView() {
	+ return (bool)strlen($this->getTagText());
	+ }
	+
	+ public function newTagView() {
	+ $view = id(new PHUITagView())
	+ ->setType(PHUITagView::TYPE_OUTLINE)
	+ ->setName($this->getTagText());
	+
	+ $color = $this->getColor();
	+ if ($color) {
	+ $view->setColor($color);
	+ }
	+
	+ return $view;
	}

	public static function validateSubtypeKey($subtype) {
	if (strlen($subtype) > 64) {
	throw new Exception(
	pht(
	'Subtype "%s" is not valid: subtype keys must be no longer than '.
	'64 bytes.',
	$subtype));
	}

	if (strlen($subtype) < 3) {
	throw new Exception(
	pht(
	'Subtype "%s" is not valid: subtype keys must have a minimum '.
	'length of 3 bytes.',
	$subtype));
	}

	if (!preg_match('/^[a-z]+\z/', $subtype)) {
	throw new Exception(
	pht(
	'Subtype "%s" is not valid: subtype keys may only contain '.
	'lowercase latin letters ("a" through "z").',
	$subtype));
	}
	}

	public static function validateConfiguration($config) {
	if (!is_array($config)) {
	throw new Exception(
	pht(
	'Subtype configuration is invalid: it must be a list of subtype '.
	'specifications.'));
	}

	$map = array();
	foreach ($config as $value) {
	PhutilTypeSpec::checkMap(
	$value,
	array(
	'key' => 'string',
	'name' => 'string',
	+ 'tag' => 'optional string',
	+ 'color' => 'optional string',
	+ 'icon' => 'optional string',
	));

	$key = $value['key'];
	self::validateSubtypeKey($key);

	if (isset($map[$key])) {
	throw new Exception(
	pht(
	'Subtype configuration is invalid: two subtypes use the same '.
	'key ("%s"). Each subtype must have a unique key.',
	$key));
	}

	$map[$key] = true;

	$name = $value['name'];
	if (!strlen($name)) {
	throw new Exception(
	pht(
	'Subtype configuration is invalid: subtype with key "%s" has '.
	'no name. Subtypes must have a name.',
	$key));
	}
	}

	if (!isset($map[self::SUBTYPE_DEFAULT])) {
	throw new Exception(
	pht(
	'Subtype configuration is invalid: there is no subtype defined '.
	'with key "%s". This subtype is required and must be defined.',
	self::SUBTYPE_DEFAULT));
	}
	}

	public static function newSubtypeMap(array $config) {
	$map = array();

	foreach ($config as $entry) {
	$key = $entry['key'];
	$name = $entry['name'];

	- $map[$key] = id(new self())
	+ $tag_text = idx($entry, 'tag');
	+ if ($tag_text === null) {
	+ if ($key != self::SUBTYPE_DEFAULT) {
	+ $tag_text = phutil_utf8_strtoupper($name);
	+ }
	+ }
	+
	+ $color = idx($entry, 'color', 'blue');
	+ $icon = idx($entry, 'icon', 'fa-drivers-license-o');
	+
	+ $subtype = id(new self())
	->setKey($key)
	- ->setName($name);
	+ ->setName($name)
	+ ->setTagText($tag_text)
	+ ->setIcon($icon);
	+
	+ if ($color) {
	+ $subtype->setColor($color);
	+ }
	+
	+ $map[$key] = $subtype;
	}

	return $map;
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jul 17, 12:18 AM (6 h, 53 m)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 8a/0a/b2bbdb6a833b1362a8a3aacde8d6

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions