No OneTemporary
Actions

Size

81 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/maniphest/controller/ManiphestTaskEditController.php b/src/applications/maniphest/controller/ManiphestTaskEditController.php
	index a4c13242b0..ad7e306c36 100644
	--- a/src/applications/maniphest/controller/ManiphestTaskEditController.php
	+++ b/src/applications/maniphest/controller/ManiphestTaskEditController.php
	@@ -1,742 +1,742 @@
	<?php

	final class ManiphestTaskEditController extends ManiphestController {

	private $id;

	public function willProcessRequest(array $data) {
	$this->id = idx($data, 'id');
	}

	public function processRequest() {

	$request = $this->getRequest();
	$user = $request->getUser();
	$response_type = $request->getStr('responseType', 'task');

	$can_edit_assign = $this->hasApplicationCapability(
	ManiphestCapabilityEditAssign::CAPABILITY);
	$can_edit_policies = $this->hasApplicationCapability(
	ManiphestCapabilityEditPolicies::CAPABILITY);
	$can_edit_priority = $this->hasApplicationCapability(
	ManiphestCapabilityEditPriority::CAPABILITY);
	$can_edit_projects = $this->hasApplicationCapability(
	ManiphestCapabilityEditProjects::CAPABILITY);
	$can_edit_status = $this->hasApplicationCapability(
	ManiphestCapabilityEditStatus::CAPABILITY);

	$parent_task = null;
	$template_id = null;

	if ($this->id) {
	$task = id(new ManiphestTaskQuery())
	->setViewer($user)
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->withIDs(array($this->id))
	->executeOne();
	if (!$task) {
	return new Aphront404Response();
	}
	} else {
	$task = ManiphestTask::initializeNewTask($user);

	// We currently do not allow you to set the task status when creating
	// a new task, although now that statuses are custom it might make
	// sense.
	$can_edit_status = false;

	// These allow task creation with defaults.
	if (!$request->isFormPost()) {
	$task->setTitle($request->getStr('title'));

	if ($can_edit_projects) {
	$projects = $request->getStr('projects');
	if ($projects) {
	$tokens = $request->getStrList('projects');

	$type_project = PhabricatorProjectPHIDTypeProject::TYPECONST;
	foreach ($tokens as $key => $token) {
	if (phid_get_type($token) == $type_project) {
	// If this is formatted like a PHID, leave it as-is.
	continue;
	}

	if (preg_match('/^#/', $token)) {
	// If this already has a "#", leave it as-is.
	continue;
	}

	// Add a "#" prefix.
	$tokens[$key] = '#'.$token;
	}

	$default_projects = id(new PhabricatorObjectQuery())
	->setViewer($user)
	->withNames($tokens)
	->execute();
	$default_projects = mpull($default_projects, 'getPHID');

	if ($default_projects) {
	- $task->setProjectPHIDs($default_projects);
	+ $task->attachProjectPHIDs($default_projects);
	}
	}
	}

	if ($can_edit_priority) {
	$priority = $request->getInt('priority');
	if ($priority !== null) {
	$priority_map = ManiphestTaskPriority::getTaskPriorityMap();
	if (isset($priority_map[$priority])) {
	$task->setPriority($priority);
	}
	}
	}

	$task->setDescription($request->getStr('description'));

	if ($can_edit_assign) {
	$assign = $request->getStr('assign');
	if (strlen($assign)) {
	$assign_user = id(new PhabricatorPeopleQuery())
	->setViewer($user)
	->withUsernames(array($assign))
	->executeOne();
	if (!$assign_user) {
	$assign_user = id(new PhabricatorPeopleQuery())
	->setViewer($user)
	->withPHIDs(array($assign))
	->executeOne();
	}

	if ($assign_user) {
	$task->setOwnerPHID($assign_user->getPHID());
	}
	}
	}
	}

	$template_id = $request->getInt('template');

	// You can only have a parent task if you're creating a new task.
	$parent_id = $request->getInt('parent');
	if ($parent_id) {
	$parent_task = id(new ManiphestTaskQuery())
	->setViewer($user)
	->withIDs(array($parent_id))
	->executeOne();
	if (!$template_id) {
	$template_id = $parent_id;
	}
	}
	}

	$errors = array();
	$e_title = true;

	$field_list = PhabricatorCustomField::getObjectFields(
	$task,
	PhabricatorCustomField::ROLE_EDIT);
	$field_list->setViewer($user);
	$field_list->readFieldsFromStorage($task);

	$aux_fields = $field_list->getFields();

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

	$new_title = $request->getStr('title');
	$new_desc = $request->getStr('description');
	$new_status = $request->getStr('status');

	if (!$task->getID()) {
	$workflow = 'create';
	} else {
	$workflow = '';
	}

	$changes[ManiphestTransaction::TYPE_TITLE] = $new_title;
	$changes[ManiphestTransaction::TYPE_DESCRIPTION] = $new_desc;

	if ($can_edit_status) {
	$changes[ManiphestTransaction::TYPE_STATUS] = $new_status;
	} else if (!$task->getID()) {
	// Create an initial status transaction for the burndown chart.
	// TODO: We can probably remove this once Facts comes online.
	$changes[ManiphestTransaction::TYPE_STATUS] = $task->getStatus();
	}

	$owner_tokenizer = $request->getArr('assigned_to');
	$owner_phid = reset($owner_tokenizer);

	if (!strlen($new_title)) {
	$e_title = pht('Required');
	$errors[] = pht('Title is required.');
	}

	$old_values = array();
	foreach ($aux_fields as $aux_arr_key => $aux_field) {
	// TODO: This should be buildFieldTransactionsFromRequest() once we
	// switch to ApplicationTransactions properly.

	$aux_old_value = $aux_field->getOldValueForApplicationTransactions();
	$aux_field->readValueFromRequest($request);
	$aux_new_value = $aux_field->getNewValueForApplicationTransactions();

	// TODO: We're faking a call to the ApplicaitonTransaction validation
	// logic here. We need valid objects to pass, but they aren't used
	// in a meaningful way. For now, build User objects. Once the Maniphest
	// objects exist, this will switch over automatically. This is a big
	// hack but shouldn't be long for this world.
	$placeholder_editor = new PhabricatorUserProfileEditor();

	$field_errors = $aux_field->validateApplicationTransactions(
	$placeholder_editor,
	PhabricatorTransactions::TYPE_CUSTOMFIELD,
	array(
	id(new ManiphestTransaction())
	->setOldValue($aux_old_value)
	->setNewValue($aux_new_value),
	));

	foreach ($field_errors as $error) {
	$errors[] = $error->getMessage();
	}

	$old_values[$aux_field->getFieldKey()] = $aux_old_value;
	}

	if ($errors) {
	$task->setTitle($new_title);
	$task->setDescription($new_desc);
	$task->setPriority($request->getInt('priority'));
	$task->setOwnerPHID($owner_phid);
	$task->setCCPHIDs($request->getArr('cc'));
	- $task->setProjectPHIDs($request->getArr('projects'));
	+ $task->attachProjectPHIDs($request->getArr('projects'));
	} else {

	if ($can_edit_priority) {
	$changes[ManiphestTransaction::TYPE_PRIORITY] =
	$request->getInt('priority');
	}
	if ($can_edit_assign) {
	$changes[ManiphestTransaction::TYPE_OWNER] = $owner_phid;
	}

	$changes[ManiphestTransaction::TYPE_CCS] = $request->getArr('cc');

	if ($can_edit_projects) {
	$projects = $request->getArr('projects');
	$changes[ManiphestTransaction::TYPE_PROJECTS] =
	$projects;
	$column_phid = $request->getStr('columnPHID');
	// allow for putting a task in a project column at creation -only-
	if (!$task->getID() && $column_phid && $projects) {
	$column = id(new PhabricatorProjectColumnQuery())
	->setViewer($user)
	->withProjectPHIDs($projects)
	->withPHIDs(array($column_phid))
	->executeOne();
	if ($column) {
	$changes[ManiphestTransaction::TYPE_PROJECT_COLUMN] =
	array(
	'new' => array(
	'projectPHID' => $column->getProjectPHID(),
	'columnPHIDs' => array($column_phid)),
	'old' => array(
	'projectPHID' => $column->getProjectPHID(),
	'columnPHIDs' => array()));
	}
	}
	}

	if ($can_edit_policies) {
	$changes[PhabricatorTransactions::TYPE_VIEW_POLICY] =
	$request->getStr('viewPolicy');
	$changes[PhabricatorTransactions::TYPE_EDIT_POLICY] =
	$request->getStr('editPolicy');
	}

	$template = new ManiphestTransaction();
	$transactions = array();

	foreach ($changes as $type => $value) {
	$transaction = clone $template;
	$transaction->setTransactionType($type);
	if ($type == ManiphestTransaction::TYPE_PROJECT_COLUMN) {
	$transaction->setNewValue($value['new']);
	$transaction->setOldValue($value['old']);
	} else {
	$transaction->setNewValue($value);
	}
	$transactions[] = $transaction;
	}

	if ($aux_fields) {
	foreach ($aux_fields as $aux_field) {
	$transaction = clone $template;
	$transaction->setTransactionType(
	PhabricatorTransactions::TYPE_CUSTOMFIELD);
	$aux_key = $aux_field->getFieldKey();
	$transaction->setMetadataValue('customfield:key', $aux_key);
	$old = idx($old_values, $aux_key);
	$new = $aux_field->getNewValueForApplicationTransactions();

	$transaction->setOldValue($old);
	$transaction->setNewValue($new);

	$transactions[] = $transaction;
	}
	}

	if ($transactions) {
	$is_new = !$task->getID();

	$event = new PhabricatorEvent(
	PhabricatorEventType::TYPE_MANIPHEST_WILLEDITTASK,
	array(
	'task' => $task,
	'new' => $is_new,
	'transactions' => $transactions,
	));
	$event->setUser($user);
	$event->setAphrontRequest($request);
	PhutilEventEngine::dispatchEvent($event);

	$task = $event->getValue('task');
	$transactions = $event->getValue('transactions');

	$editor = id(new ManiphestTransactionEditor())
	->setActor($user)
	->setContentSourceFromRequest($request)
	->setContinueOnNoEffect(true)
	->applyTransactions($task, $transactions);

	$event = new PhabricatorEvent(
	PhabricatorEventType::TYPE_MANIPHEST_DIDEDITTASK,
	array(
	'task' => $task,
	'new' => $is_new,
	'transactions' => $transactions,
	));
	$event->setUser($user);
	$event->setAphrontRequest($request);
	PhutilEventEngine::dispatchEvent($event);
	}


	if ($parent_task) {
	id(new PhabricatorEdgeEditor())
	->addEdge(
	$parent_task->getPHID(),
	PhabricatorEdgeConfig::TYPE_TASK_DEPENDS_ON_TASK,
	$task->getPHID())
	->save();
	$workflow = $parent_task->getID();
	}

	if ($request->isAjax()) {
	switch ($response_type) {
	case 'card':
	$owner = null;
	if ($task->getOwnerPHID()) {
	$owner = id(new PhabricatorHandleQuery())
	->setViewer($user)
	->withPHIDs(array($task->getOwnerPHID()))
	->executeOne();
	}
	$tasks = id(new ProjectBoardTaskCard())
	->setViewer($user)
	->setTask($task)
	->setOwner($owner)
	->setCanEdit(true)
	->getItem();
	$column_phid = $request->getStr('columnPHID');
	$column = id(new PhabricatorProjectColumnQuery())
	->setViewer($user)
	->withPHIDs(array($column_phid))
	->executeOne();
	if ($column->isDefaultColumn()) {
	$column_tasks = array();
	$potential_col_tasks = id(new ManiphestTaskQuery())
	->setViewer($user)
	->withAllProjects(array($column->getProjectPHID()))
	->execute();
	$potential_col_tasks = mpull(
	$potential_col_tasks,
	null,
	'getPHID');
	$potential_task_phids = array_keys($potential_col_tasks);
	if ($potential_task_phids) {
	$edge_type = PhabricatorEdgeConfig::TYPE_OBJECT_HAS_COLUMN;
	$edge_query = id(new PhabricatorEdgeQuery())
	->withSourcePHIDs($potential_task_phids)
	->withEdgeTypes(array($edge_type));
	$edges = $edge_query->execute();
	foreach ($potential_col_tasks as $task_phid => $curr_task) {
	$curr_column_phids = $edges[$task_phid][$edge_type];
	$curr_column_phid = head_key($curr_column_phids);
	if (!$curr_column_phid \|\|
	$curr_column_phid == $column_phid) {
	$column_tasks[] = $curr_task;
	}
	}
	}
	} else {
	$column_task_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$column_phid,
	PhabricatorEdgeConfig::TYPE_COLUMN_HAS_OBJECT);
	$column_tasks = id(new ManiphestTaskQuery())
	->setViewer($user)
	->withPHIDs($column_task_phids)
	->execute();
	}

	$sort_map = mpull(
	$column_tasks,
	'getPrioritySortVector',
	'getPHID');

	$data = array(
	'sortMap' => $sort_map,
	);
	break;
	case 'task':
	default:
	$tasks = $this->renderSingleTask($task);
	$data = array();
	break;
	}
	return id(new AphrontAjaxResponse())->setContent(
	array(
	'tasks' => $tasks,
	'data' => $data,
	));
	}

	$redirect_uri = '/T'.$task->getID();

	if ($workflow) {
	$redirect_uri .= '?workflow='.$workflow;
	}

	return id(new AphrontRedirectResponse())
	->setURI($redirect_uri);
	}
	} else {
	if (!$task->getID()) {
	$task->setCCPHIDs(array(
	$user->getPHID(),
	));
	if ($template_id) {
	$template_task = id(new ManiphestTaskQuery())
	->setViewer($user)
	->withIDs(array($template_id))
	->executeOne();
	if ($template_task) {
	$task->setCCPHIDs($template_task->getCCPHIDs());
	- $task->setProjectPHIDs($template_task->getProjectPHIDs());
	+ $task->attachProjectPHIDs($template_task->getProjectPHIDs());
	$task->setOwnerPHID($template_task->getOwnerPHID());
	$task->setPriority($template_task->getPriority());
	$task->setViewPolicy($template_task->getViewPolicy());
	$task->setEditPolicy($template_task->getEditPolicy());

	$template_fields = PhabricatorCustomField::getObjectFields(
	$template_task,
	PhabricatorCustomField::ROLE_EDIT);

	$fields = $template_fields->getFields();
	foreach ($fields as $key => $field) {
	if (!$field->shouldCopyWhenCreatingSimilarTask()) {
	unset($fields[$key]);
	}
	if (empty($aux_fields[$key])) {
	unset($fields[$key]);
	}
	}

	if ($fields) {
	id(new PhabricatorCustomFieldList($fields))
	->setViewer($user)
	->readFieldsFromStorage($template_task);

	foreach ($fields as $key => $field) {
	$aux_fields[$key]->setValueFromStorage(
	$field->getValueForStorage());
	}
	}
	}
	}
	}
	}

	$phids = array_merge(
	array($task->getOwnerPHID()),
	$task->getCCPHIDs(),
	$task->getProjectPHIDs());

	if ($parent_task) {
	$phids[] = $parent_task->getPHID();
	}

	$phids = array_filter($phids);
	$phids = array_unique($phids);

	$handles = $this->loadViewerHandles($phids);

	$error_view = null;
	if ($errors) {
	$error_view = new AphrontErrorView();
	$error_view->setErrors($errors);
	}

	$priority_map = ManiphestTaskPriority::getTaskPriorityMap();

	if ($task->getOwnerPHID()) {
	$assigned_value = array($handles[$task->getOwnerPHID()]);
	} else {
	$assigned_value = array();
	}

	if ($task->getCCPHIDs()) {
	$cc_value = array_select_keys($handles, $task->getCCPHIDs());
	} else {
	$cc_value = array();
	}

	if ($task->getProjectPHIDs()) {
	$projects_value = array_select_keys($handles, $task->getProjectPHIDs());
	} else {
	$projects_value = array();
	}

	$cancel_id = nonempty($task->getID(), $template_id);
	if ($cancel_id) {
	$cancel_uri = '/T'.$cancel_id;
	} else {
	$cancel_uri = '/maniphest/';
	}

	if ($task->getID()) {
	$button_name = pht('Save Task');
	$header_name = pht('Edit Task');
	} else if ($parent_task) {
	$cancel_uri = '/T'.$parent_task->getID();
	$button_name = pht('Create Task');
	$header_name = pht('Create New Subtask');
	} else {
	$button_name = pht('Create Task');
	$header_name = pht('Create New Task');
	}

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

	$project_tokenizer_id = celerity_generate_unique_node_id();

	$form = new AphrontFormView();
	$form
	->setUser($user)
	->addHiddenInput('template', $template_id)
	->addHiddenInput('responseType', $response_type)
	->addHiddenInput('columnPHID', $request->getStr('columnPHID'));

	if ($parent_task) {
	$form
	->appendChild(
	id(new AphrontFormStaticControl())
	->setLabel(pht('Parent Task'))
	->setValue($handles[$parent_task->getPHID()]->getFullName()))
	->addHiddenInput('parent', $parent_task->getID());
	}

	$form
	->appendChild(
	id(new AphrontFormTextAreaControl())
	->setLabel(pht('Title'))
	->setName('title')
	->setError($e_title)
	->setHeight(AphrontFormTextAreaControl::HEIGHT_VERY_SHORT)
	->setValue($task->getTitle()));

	if ($can_edit_status) {
	// See T4819.
	$status_map = ManiphestTaskStatus::getTaskStatusMap();
	$dup_status = ManiphestTaskStatus::getDuplicateStatus();

	if ($task->getStatus() != $dup_status) {
	unset($status_map[$dup_status]);
	}

	$form
	->appendChild(
	id(new AphrontFormSelectControl())
	->setLabel(pht('Status'))
	->setName('status')
	->setValue($task->getStatus())
	->setOptions($status_map));
	}

	$policies = id(new PhabricatorPolicyQuery())
	->setViewer($user)
	->setObject($task)
	->execute();

	if ($can_edit_assign) {
	$form->appendChild(
	id(new AphrontFormTokenizerControl())
	->setLabel(pht('Assigned To'))
	->setName('assigned_to')
	->setValue($assigned_value)
	->setUser($user)
	->setDatasource('/typeahead/common/users/')
	->setLimit(1));
	}

	$form
	->appendChild(
	id(new AphrontFormTokenizerControl())
	->setLabel(pht('CC'))
	->setName('cc')
	->setValue($cc_value)
	->setUser($user)
	->setDatasource('/typeahead/common/mailable/'));

	if ($can_edit_priority) {
	$form
	->appendChild(
	id(new AphrontFormSelectControl())
	->setLabel(pht('Priority'))
	->setName('priority')
	->setOptions($priority_map)
	->setValue($task->getPriority()));
	}

	if ($can_edit_policies) {
	$form
	->appendChild(
	id(new AphrontFormPolicyControl())
	->setUser($user)
	->setCapability(PhabricatorPolicyCapability::CAN_VIEW)
	->setPolicyObject($task)
	->setPolicies($policies)
	->setName('viewPolicy'))
	->appendChild(
	id(new AphrontFormPolicyControl())
	->setUser($user)
	->setCapability(PhabricatorPolicyCapability::CAN_EDIT)
	->setPolicyObject($task)
	->setPolicies($policies)
	->setName('editPolicy'));
	}

	if ($can_edit_projects) {
	$form
	->appendChild(
	id(new AphrontFormTokenizerControl())
	->setLabel(pht('Projects'))
	->setName('projects')
	->setValue($projects_value)
	->setID($project_tokenizer_id)
	->setCaption(
	javelin_tag(
	'a',
	array(
	'href' => '/project/create/',
	'mustcapture' => true,
	'sigil' => 'project-create',
	),
	pht('Create New Project')))
	->setDatasource(new PhabricatorProjectDatasource()));
	}

	$field_list->appendFieldsToForm($form);

	require_celerity_resource('aphront-error-view-css');

	Javelin::initBehavior('project-create', array(
	'tokenizerID' => $project_tokenizer_id,
	));

	$description_control = new PhabricatorRemarkupControl();
	// "Upsell" creating tasks via email in create flows if the instance is
	// configured for this awesomeness.
	$email_create = PhabricatorEnv::getEnvConfig(
	'metamta.maniphest.public-create-email');
	if (!$task->getID() && $email_create) {
	$email_hint = pht(
	'You can also create tasks by sending an email to: %s',
	phutil_tag('tt', array(), $email_create));
	$description_control->setCaption($email_hint);
	}

	$description_control
	->setLabel(pht('Description'))
	->setName('description')
	->setID('description-textarea')
	->setValue($task->getDescription())
	->setUser($user);

	$form
	->appendChild($description_control);


	if ($request->isAjax()) {
	$dialog = id(new AphrontDialogView())
	->setUser($user)
	->setWidth(AphrontDialogView::WIDTH_FULL)
	->setTitle($header_name)
	->appendChild(
	array(
	$error_view,
	$form->buildLayoutView(),
	))
	->addCancelButton($cancel_uri)
	->addSubmitButton($button_name);
	return id(new AphrontDialogResponse())->setDialog($dialog);
	}

	$form
	->appendChild(
	id(new AphrontFormSubmitControl())
	->addCancelButton($cancel_uri)
	->setValue($button_name));

	$form_box = id(new PHUIObjectBoxView())
	->setHeaderText($header_name)
	->setFormErrors($errors)
	->setForm($form);

	$preview = id(new PHUIRemarkupPreviewPanel())
	->setHeader(pht('Description Preview'))
	->setControlID('description-textarea')
	->setPreviewURI($this->getApplicationURI('task/descriptionpreview/'));

	if ($task->getID()) {
	$page_objects = array($task->getPHID());
	} else {
	$page_objects = array();
	}

	$crumbs = $this->buildApplicationCrumbs();

	if ($task->getID()) {
	$crumbs->addTextCrumb('T'.$task->getID(), '/T'.$task->getID());
	}

	$crumbs->addTextCrumb($header_name);

	return $this->buildApplicationPage(
	array(
	$crumbs,
	$form_box,
	$preview,
	),
	array(
	'title' => $header_name,
	'pageObjects' => $page_objects,
	));
	}
	}
	diff --git a/src/applications/maniphest/editor/ManiphestTransactionEditor.php b/src/applications/maniphest/editor/ManiphestTransactionEditor.php
	index 5ed423bc74..d7abddbcd1 100644
	--- a/src/applications/maniphest/editor/ManiphestTransactionEditor.php
	+++ b/src/applications/maniphest/editor/ManiphestTransactionEditor.php
	@@ -1,546 +1,547 @@
	<?php

	final class ManiphestTransactionEditor
	extends PhabricatorApplicationTransactionEditor {

	private $heraldEmailPHIDs = array();

	public function getTransactionTypes() {
	$types = parent::getTransactionTypes();

	$types[] = PhabricatorTransactions::TYPE_COMMENT;
	$types[] = PhabricatorTransactions::TYPE_EDGE;
	$types[] = ManiphestTransaction::TYPE_PRIORITY;
	$types[] = ManiphestTransaction::TYPE_STATUS;
	$types[] = ManiphestTransaction::TYPE_TITLE;
	$types[] = ManiphestTransaction::TYPE_DESCRIPTION;
	$types[] = ManiphestTransaction::TYPE_OWNER;
	$types[] = ManiphestTransaction::TYPE_CCS;
	$types[] = ManiphestTransaction::TYPE_PROJECTS;
	$types[] = ManiphestTransaction::TYPE_SUBPRIORITY;
	$types[] = ManiphestTransaction::TYPE_PROJECT_COLUMN;
	$types[] = ManiphestTransaction::TYPE_UNBLOCK;
	$types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
	$types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;

	return $types;
	}

	protected function getCustomTransactionOldValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case ManiphestTransaction::TYPE_PRIORITY:
	if ($this->getIsNewObject()) {
	return null;
	}
	return (int)$object->getPriority();
	case ManiphestTransaction::TYPE_STATUS:
	if ($this->getIsNewObject()) {
	return null;
	}
	return $object->getStatus();
	case ManiphestTransaction::TYPE_TITLE:
	if ($this->getIsNewObject()) {
	return null;
	}
	return $object->getTitle();
	case ManiphestTransaction::TYPE_DESCRIPTION:
	if ($this->getIsNewObject()) {
	return null;
	}
	return $object->getDescription();
	case ManiphestTransaction::TYPE_OWNER:
	return nonempty($object->getOwnerPHID(), null);
	case ManiphestTransaction::TYPE_CCS:
	return array_values(array_unique($object->getCCPHIDs()));
	case ManiphestTransaction::TYPE_PROJECTS:
	return array_values(array_unique($object->getProjectPHIDs()));
	case ManiphestTransaction::TYPE_PROJECT_COLUMN:
	// These are pre-populated.
	return $xaction->getOldValue();
	case ManiphestTransaction::TYPE_SUBPRIORITY:
	return $object->getSubpriority();
	}

	}

	protected function getCustomTransactionNewValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case ManiphestTransaction::TYPE_PRIORITY:
	return (int)$xaction->getNewValue();
	case ManiphestTransaction::TYPE_CCS:
	case ManiphestTransaction::TYPE_PROJECTS:
	return array_values(array_unique($xaction->getNewValue()));
	case ManiphestTransaction::TYPE_OWNER:
	return nonempty($xaction->getNewValue(), null);
	case ManiphestTransaction::TYPE_STATUS:
	case ManiphestTransaction::TYPE_TITLE:
	case ManiphestTransaction::TYPE_DESCRIPTION:
	case ManiphestTransaction::TYPE_SUBPRIORITY:
	case ManiphestTransaction::TYPE_PROJECT_COLUMN:
	case ManiphestTransaction::TYPE_UNBLOCK:
	return $xaction->getNewValue();
	}
	}


	protected function transactionHasEffect(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

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

	switch ($xaction->getTransactionType()) {
	case ManiphestTransaction::TYPE_PROJECTS:
	case ManiphestTransaction::TYPE_CCS:
	sort($old);
	sort($new);
	return ($old !== $new);
	case ManiphestTransaction::TYPE_PROJECT_COLUMN:
	$new_column_phids = $new['columnPHIDs'];
	$old_column_phids = $old['columnPHIDs'];
	sort($new_column_phids);
	sort($old_column_phids);
	return ($old !== $new);
	}

	return parent::transactionHasEffect($object, $xaction);
	}

	protected function applyCustomInternalTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case ManiphestTransaction::TYPE_PRIORITY:
	return $object->setPriority($xaction->getNewValue());
	case ManiphestTransaction::TYPE_STATUS:
	return $object->setStatus($xaction->getNewValue());
	case ManiphestTransaction::TYPE_TITLE:
	return $object->setTitle($xaction->getNewValue());
	case ManiphestTransaction::TYPE_DESCRIPTION:
	return $object->setDescription($xaction->getNewValue());
	case ManiphestTransaction::TYPE_OWNER:
	$phid = $xaction->getNewValue();

	// Update the "ownerOrdering" column to contain the full name of the
	// owner, if the task is assigned.

	$handle = null;
	if ($phid) {
	$handle = id(new PhabricatorHandleQuery())
	->setViewer($this->getActor())
	->withPHIDs(array($phid))
	->executeOne();
	}

	if ($handle) {
	$object->setOwnerOrdering($handle->getName());
	} else {
	$object->setOwnerOrdering(null);
	}

	return $object->setOwnerPHID($phid);
	case ManiphestTransaction::TYPE_CCS:
	return $object->setCCPHIDs($xaction->getNewValue());
	case ManiphestTransaction::TYPE_PROJECTS:
	- $object->setProjectPHIDs($xaction->getNewValue());
	- ManiphestTaskProject::updateTaskProjects($object);
	+ ManiphestTaskProject::updateTaskProjects(
	+ $object,
	+ $xaction->getNewValue());
	return $object;
	case ManiphestTransaction::TYPE_SUBPRIORITY:
	$data = $xaction->getNewValue();
	$new_sub = $this->getNextSubpriority(
	$data['newPriority'],
	$data['newSubpriorityBase'],
	$data['direction']);
	$object->setSubpriority($new_sub);
	return;
	case ManiphestTransaction::TYPE_PROJECT_COLUMN:
	// these do external (edge) updates
	return;
	}

	}

	protected function expandTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	$xactions = parent::expandTransaction($object, $xaction);
	switch ($xaction->getTransactionType()) {
	case ManiphestTransaction::TYPE_SUBPRIORITY:
	$data = $xaction->getNewValue();
	$new_pri = $data['newPriority'];
	if ($new_pri != $object->getPriority()) {
	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(ManiphestTransaction::TYPE_PRIORITY)
	->setNewValue($new_pri);
	}
	break;
	default:
	break;
	}

	return $xactions;
	}

	protected function applyCustomExternalTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case ManiphestTransaction::TYPE_PROJECT_COLUMN:
	$new = $xaction->getNewValue();
	$old = $xaction->getOldValue();
	$src = $object->getPHID();
	$dst = head($new['columnPHIDs']);
	$edges = $old['columnPHIDs'];
	$edge_type = PhabricatorEdgeConfig::TYPE_OBJECT_HAS_COLUMN;
	// NOTE: Normally, we expect only one edge to exist, but this works in
	// a general way so it will repair any stray edges.
	$remove = array();
	$edge_missing = true;
	foreach ($edges as $phid) {
	if ($phid == $dst) {
	$edge_missing = false;
	} else {
	$remove[] = $phid;
	}
	}

	$add = array();
	if ($edge_missing) {
	$add[] = $dst;
	}

	// This should never happen because of the code in
	// transactionHasEffect, but keep it for maximum conservativeness
	if (!$add && !$remove) {
	return;
	}

	$editor = new PhabricatorEdgeEditor();
	foreach ($add as $phid) {
	$editor->addEdge($src, $edge_type, $phid);
	}
	foreach ($remove as $phid) {
	$editor->removeEdge($src, $edge_type, $phid);
	}
	$editor->save();
	break;
	default:
	break;
	}
	}

	protected function applyFinalEffects(
	PhabricatorLiskDAO $object,
	array $xactions) {

	// When we change the status of a task, update tasks this tasks blocks
	// with a message to the effect of "alincoln resolved blocking task Txxx."
	$unblock_xaction = null;
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case ManiphestTransaction::TYPE_STATUS:
	$unblock_xaction = $xaction;
	break;
	}
	}

	if ($unblock_xaction !== null) {
	$blocked_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$object->getPHID(),
	PhabricatorEdgeConfig::TYPE_TASK_DEPENDED_ON_BY_TASK);
	if ($blocked_phids) {
	// In theory we could apply these through policies, but that seems a
	// little bit surprising. For now, use the actor's vision.
	$blocked_tasks = id(new ManiphestTaskQuery())
	->setViewer($this->getActor())
	->withPHIDs($blocked_phids)
	->execute();

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

	foreach ($blocked_tasks as $blocked_task) {
	$xactions = array();

	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(ManiphestTransaction::TYPE_UNBLOCK)
	->setOldValue(array($object->getPHID() => $old))
	->setNewValue(array($object->getPHID() => $new));

	// TODO: We should avoid notifiying users about these indirect
	// changes if they are getting a notification about the current
	// change, so you don't get a pile of extra notifications if you are
	// subscribed to this task.

	id(new ManiphestTransactionEditor())
	->setActor($this->getActor())
	->setContentSource($this->getContentSource())
	->setContinueOnNoEffect(true)
	->setContinueOnMissingFields(true)
	->applyTransactions($blocked_task, $xactions);
	}
	}
	}

	return $xactions;
	}


	protected function shouldSendMail(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$xactions = mfilter($xactions, 'shouldHide', true);
	return $xactions;
	}

	protected function getMailSubjectPrefix() {
	return PhabricatorEnv::getEnvConfig('metamta.maniphest.subject-prefix');
	}

	protected function getMailThreadID(PhabricatorLiskDAO $object) {
	return 'maniphest-task-'.$object->getPHID();
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	return array(
	$object->getOwnerPHID(),
	$this->requireActor()->getPHID(),
	);
	}

	protected function getMailCC(PhabricatorLiskDAO $object) {
	$phids = array();

	foreach ($object->getCCPHIDs() as $phid) {
	$phids[] = $phid;
	}

	foreach (parent::getMailCC($object) as $phid) {
	$phids[] = $phid;
	}

	foreach ($this->heraldEmailPHIDs as $phid) {
	$phids[] = $phid;
	}

	return $phids;
	}

	protected function buildReplyHandler(PhabricatorLiskDAO $object) {
	return id(new ManiphestReplyHandler())
	->setMailReceiver($object);
	}

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	$id = $object->getID();
	$title = $object->getTitle();

	return id(new PhabricatorMetaMTAMail())
	->setSubject("T{$id}: {$title}")
	->addHeader('Thread-Topic', "T{$id}: ".$object->getOriginalTitle());
	}

	protected function buildMailBody(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$body = parent::buildMailBody($object, $xactions);

	if ($this->getIsNewObject()) {
	$body->addTextSection(
	pht('TASK DESCRIPTION'),
	$object->getDescription());
	}

	$body->addTextSection(
	pht('TASK DETAIL'),
	PhabricatorEnv::getProductionURI('/T'.$object->getID()));

	return $body;
	}

	protected function shouldPublishFeedStory(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return $this->shouldSendMail($object, $xactions);
	}

	protected function supportsSearch() {
	return true;
	}

	protected function shouldApplyHeraldRules(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return true;
	}

	protected function buildHeraldAdapter(
	PhabricatorLiskDAO $object,
	array $xactions) {

	return id(new HeraldManiphestTaskAdapter())
	->setTask($object);
	}

	protected function didApplyHeraldRules(
	PhabricatorLiskDAO $object,
	HeraldAdapter $adapter,
	HeraldTranscript $transcript) {

	// TODO: Convert these to transactions. The way Maniphest deals with these
	// transactions is currently unconventional and messy.

	$save_again = false;
	$cc_phids = $adapter->getCcPHIDs();
	if ($cc_phids) {
	$existing_cc = $object->getCCPHIDs();
	$new_cc = array_unique(array_merge($cc_phids, $existing_cc));
	$object->setCCPHIDs($new_cc);
	$object->save();
	}

	$this->heraldEmailPHIDs = $adapter->getEmailPHIDs();

	$xactions = array();

	$assign_phid = $adapter->getAssignPHID();
	if ($assign_phid) {
	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(ManiphestTransaction::TYPE_OWNER)
	->setNewValue($assign_phid);
	}

	$project_phids = $adapter->getProjectPHIDs();
	if ($project_phids) {
	$existing_projects = $object->getProjectPHIDs();
	$new_projects = array_unique(
	array_merge(
	$project_phids,
	$existing_projects));

	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(ManiphestTransaction::TYPE_PROJECTS)
	->setNewValue($new_projects);
	}

	return $xactions;
	}

	protected function requireCapabilities(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	parent::requireCapabilities($object, $xaction);

	$app_capability_map = array(
	ManiphestTransaction::TYPE_PRIORITY =>
	ManiphestCapabilityEditPriority::CAPABILITY,
	ManiphestTransaction::TYPE_STATUS =>
	ManiphestCapabilityEditStatus::CAPABILITY,
	ManiphestTransaction::TYPE_PROJECTS =>
	ManiphestCapabilityEditProjects::CAPABILITY,
	ManiphestTransaction::TYPE_OWNER =>
	ManiphestCapabilityEditAssign::CAPABILITY,
	PhabricatorTransactions::TYPE_EDIT_POLICY =>
	ManiphestCapabilityEditPolicies::CAPABILITY,
	PhabricatorTransactions::TYPE_VIEW_POLICY =>
	ManiphestCapabilityEditPolicies::CAPABILITY,
	);

	$transaction_type = $xaction->getTransactionType();
	$app_capability = idx($app_capability_map, $transaction_type);

	if ($app_capability) {
	$app = id(new PhabricatorApplicationQuery())
	->setViewer($this->getActor())
	->withClasses(array('PhabricatorApplicationManiphest'))
	->executeOne();
	PhabricatorPolicyFilter::requireCapability(
	$this->getActor(),
	$app,
	$app_capability);
	}
	}

	protected function adjustObjectForPolicyChecks(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$copy = parent::adjustObjectForPolicyChecks($object, $xactions);
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case ManiphestTransaction::TYPE_OWNER:
	$copy->setOwnerPHID($xaction->getNewValue());
	break;
	default:
	continue;
	}
	}

	return $copy;
	}

	private function getNextSubpriority($pri, $sub, $dir = '>') {

	switch ($dir) {
	case '>':
	$order = 'ASC';
	break;
	case '<':
	$order = 'DESC';
	break;
	default:
	throw new Exception('$dir must be ">" or "<".');
	break;
	}

	if ($sub === null) {
	$base = 0;
	} else {
	$base = $sub;
	}

	if ($sub === null) {
	$next = id(new ManiphestTask())->loadOneWhere(
	'priority = %d ORDER BY subpriority %Q LIMIT 1',
	$pri,
	$order);
	if ($next) {
	if ($dir == '>') {
	return $next->getSubpriority() - ((double)(2 << 16));
	} else {
	return $next->getSubpriority() + ((double)(2 << 16));
	}
	}
	} else {
	$next = id(new ManiphestTask())->loadOneWhere(
	'priority = %d AND subpriority %Q %f ORDER BY subpriority %Q LIMIT 1',
	$pri,
	$dir,
	$sub,
	$order);
	if ($next) {
	return ($sub + $next->getSubpriority()) / 2;
	}
	}

	if ($dir == '>') {
	return $base + (double)(2 << 32);
	} else {
	return $base - (double)(2 << 32);
	}
	}

	}
	diff --git a/src/applications/maniphest/query/ManiphestTaskQuery.php b/src/applications/maniphest/query/ManiphestTaskQuery.php
	index 7e7616c0c8..5c1d17bc8f 100644
	--- a/src/applications/maniphest/query/ManiphestTaskQuery.php
	+++ b/src/applications/maniphest/query/ManiphestTaskQuery.php
	@@ -1,952 +1,973 @@
	<?php

	/**
	* Query tasks by specific criteria. This class uses the higher-performance
	* but less-general Maniphest indexes to satisfy queries.
	*/
	final class ManiphestTaskQuery extends PhabricatorCursorPagedPolicyAwareQuery {

	private $taskIDs = array();
	private $taskPHIDs = array();
	private $authorPHIDs = array();
	private $ownerPHIDs = array();
	private $includeUnowned = null;
	private $projectPHIDs = array();
	private $xprojectPHIDs = array();
	private $subscriberPHIDs = array();
	private $anyProjectPHIDs = array();
	private $anyUserProjectPHIDs = array();
	private $includeNoProject = null;
	private $dateCreatedAfter;
	private $dateCreatedBefore;
	private $dateModifiedAfter;
	private $dateModifiedBefore;

	private $fullTextSearch = '';

	private $status = 'status-any';
	const STATUS_ANY = 'status-any';
	const STATUS_OPEN = 'status-open';
	const STATUS_CLOSED = 'status-closed';
	const STATUS_RESOLVED = 'status-resolved';
	const STATUS_WONTFIX = 'status-wontfix';
	const STATUS_INVALID = 'status-invalid';
	const STATUS_SPITE = 'status-spite';
	const STATUS_DUPLICATE = 'status-duplicate';

	private $statuses;
	private $priorities;

	private $groupBy = 'group-none';
	const GROUP_NONE = 'group-none';
	const GROUP_PRIORITY = 'group-priority';
	const GROUP_OWNER = 'group-owner';
	const GROUP_STATUS = 'group-status';
	const GROUP_PROJECT = 'group-project';

	private $orderBy = 'order-modified';
	const ORDER_PRIORITY = 'order-priority';
	const ORDER_CREATED = 'order-created';
	const ORDER_MODIFIED = 'order-modified';
	const ORDER_TITLE = 'order-title';

	const DEFAULT_PAGE_SIZE = 1000;

	public function withAuthors(array $authors) {
	$this->authorPHIDs = $authors;
	return $this;
	}

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

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

	public function withOwners(array $owners) {
	$this->includeUnowned = false;
	foreach ($owners as $k => $phid) {
	if ($phid == ManiphestTaskOwner::OWNER_UP_FOR_GRABS \|\| $phid === null) {
	$this->includeUnowned = true;
	unset($owners[$k]);
	break;
	}
	}
	$this->ownerPHIDs = $owners;
	return $this;
	}

	public function withAllProjects(array $projects) {
	$this->includeNoProject = false;
	foreach ($projects as $k => $phid) {
	if ($phid == ManiphestTaskOwner::PROJECT_NO_PROJECT) {
	$this->includeNoProject = true;
	unset($projects[$k]);
	}
	}
	$this->projectPHIDs = $projects;
	return $this;
	}

	/**
	* Add an additional "all projects" constraint to existing filters.
	*
	* This is used by boards to supplement queries.
	*
	* @param list<phid> List of project PHIDs to add to any existing constriant.
	* @return this
	*/
	public function addWithAllProjects(array $projects) {
	if ($this->projectPHIDs === null) {
	$this->projectPHIDs = array();
	}

	return $this->withAllProjects(array_merge($this->projectPHIDs, $projects));
	}

	public function withoutProjects(array $projects) {
	$this->xprojectPHIDs = $projects;
	return $this;
	}

	public function withStatus($status) {
	$this->status = $status;
	return $this;
	}

	public function withStatuses(array $statuses) {
	$this->statuses = $statuses;
	return $this;
	}

	public function withPriorities(array $priorities) {
	$this->priorities = $priorities;
	return $this;
	}

	public function withSubscribers(array $subscribers) {
	$this->subscriberPHIDs = $subscribers;
	return $this;
	}

	public function withFullTextSearch($fulltext_search) {
	$this->fullTextSearch = $fulltext_search;
	return $this;
	}

	public function setGroupBy($group) {
	$this->groupBy = $group;
	return $this;
	}

	public function setOrderBy($order) {
	$this->orderBy = $order;
	return $this;
	}

	public function withAnyProjects(array $projects) {
	$this->anyProjectPHIDs = $projects;
	return $this;
	}

	public function withAnyUserProjects(array $users) {
	$this->anyUserProjectPHIDs = $users;
	return $this;
	}

	public function withDateCreatedBefore($date_created_before) {
	$this->dateCreatedBefore = $date_created_before;
	return $this;
	}

	public function withDateCreatedAfter($date_created_after) {
	$this->dateCreatedAfter = $date_created_after;
	return $this;
	}

	public function withDateModifiedBefore($date_modified_before) {
	$this->dateModifiedBefore = $date_modified_before;
	return $this;
	}

	public function withDateModifiedAfter($date_modified_after) {
	$this->dateModifiedAfter = $date_modified_after;
	return $this;
	}

	public function loadPage() {
	// TODO: (T603) It is possible for a user to find the PHID of a project
	// they can't see, then query for tasks in that project and deduce the
	// identity of unknown/invisible projects. Before we allow the user to
	// execute a project-based PHID query, we should verify that they
	// can see the project.

	$task_dao = new ManiphestTask();
	$conn = $task_dao->establishConnection('r');

	$where = array();
	$where[] = $this->buildTaskIDsWhereClause($conn);
	$where[] = $this->buildTaskPHIDsWhereClause($conn);
	$where[] = $this->buildStatusWhereClause($conn);
	$where[] = $this->buildStatusesWhereClause($conn);
	$where[] = $this->buildPrioritiesWhereClause($conn);
	$where[] = $this->buildAuthorWhereClause($conn);
	$where[] = $this->buildOwnerWhereClause($conn);
	$where[] = $this->buildSubscriberWhereClause($conn);
	$where[] = $this->buildProjectWhereClause($conn);
	$where[] = $this->buildAnyProjectWhereClause($conn);
	$where[] = $this->buildAnyUserProjectWhereClause($conn);
	$where[] = $this->buildXProjectWhereClause($conn);
	$where[] = $this->buildFullTextWhereClause($conn);

	if ($this->dateCreatedAfter) {
	$where[] = qsprintf(
	$conn,
	'dateCreated >= %d',
	$this->dateCreatedAfter);
	}

	if ($this->dateCreatedBefore) {
	$where[] = qsprintf(
	$conn,
	'dateCreated <= %d',
	$this->dateCreatedBefore);
	}

	if ($this->dateModifiedAfter) {
	$where[] = qsprintf(
	$conn,
	'dateModified >= %d',
	$this->dateModifiedAfter);
	}

	if ($this->dateModifiedBefore) {
	$where[] = qsprintf(
	$conn,
	'dateModified <= %d',
	$this->dateModifiedBefore);
	}

	$where[] = $this->buildPagingClause($conn);

	$where = $this->formatWhereClause($where);

	$having = '';
	$count = '';

	if (count($this->projectPHIDs) > 1) {
	// We want to treat the query as an intersection query, not a union
	// query. We sum the project count and require it be the same as the
	// number of projects we're searching for.

	$count = ', COUNT(project.dst) projectCount';
	$having = qsprintf(
	$conn,
	'HAVING projectCount = %d',
	count($this->projectPHIDs));
	}

	$order = $this->buildCustomOrderClause($conn);

	// TODO: Clean up this nonstandardness.
	if (!$this->getLimit()) {
	$this->setLimit(self::DEFAULT_PAGE_SIZE);
	}

	$group_column = '';
	switch ($this->groupBy) {
	case self::GROUP_PROJECT:
	$group_column = qsprintf(
	$conn,
	', projectGroupName.indexedObjectPHID projectGroupPHID');
	break;
	}

	$rows = queryfx_all(
	$conn,
	'SELECT task.* %Q %Q FROM %T task %Q %Q %Q %Q %Q %Q',
	$count,
	$group_column,
	$task_dao->getTableName(),
	$this->buildJoinsClause($conn),
	$where,
	$this->buildGroupClause($conn),
	$having,
	$order,
	$this->buildLimitClause($conn));

	switch ($this->groupBy) {
	case self::GROUP_PROJECT:
	$data = ipull($rows, null, 'id');
	break;
	default:
	$data = $rows;
	break;
	}

	$tasks = $task_dao->loadAllFromArray($data);

	switch ($this->groupBy) {
	case self::GROUP_PROJECT:
	$results = array();
	foreach ($rows as $row) {
	$task = clone $tasks[$row['id']];
	$task->attachGroupByProjectPHID($row['projectGroupPHID']);
	$results[] = $task;
	}
	$tasks = $results;
	break;
	}

	return $tasks;
	}

	protected function willFilterPage(array $tasks) {
	if ($this->groupBy == self::GROUP_PROJECT) {
	// We should only return project groups which the user can actually see.
	$project_phids = mpull($tasks, 'getGroupByProjectPHID');
	$projects = id(new PhabricatorProjectQuery())
	->setViewer($this->getViewer())
	->withPHIDs($project_phids)
	->execute();
	$projects = mpull($projects, null, 'getPHID');

	foreach ($tasks as $key => $task) {
	if (!$task->getGroupByProjectPHID()) {
	// This task is either not in any projects, or only in projects
	// which we're ignoring because they're being queried for explicitly.
	continue;
	}

	if (empty($projects[$task->getGroupByProjectPHID()])) {
	unset($tasks[$key]);
	}
	}
	}

	return $tasks;
	}

	+ protected function didFilterPage(array $tasks) {
	+ // TODO: Eventually, we should make this optional and introduce a
	+ // needProjectPHIDs() method, but for now there's a lot of code which
	+ // assumes the data is always populated.
	+
	+ $edge_query = id(new PhabricatorEdgeQuery())
	+ ->withSourcePHIDs(mpull($tasks, 'getPHID'))
	+ ->withEdgeTypes(
	+ array(
	+ PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
	+ ));
	+ $edge_query->execute();
	+
	+ foreach ($tasks as $task) {
	+ $phids = $edge_query->getDestinationPHIDs(array($task->getPHID()));
	+ $task->attachProjectPHIDs($phids);
	+ }
	+
	+ return $tasks;
	+ }
	+
	private function buildTaskIDsWhereClause(AphrontDatabaseConnection $conn) {
	if (!$this->taskIDs) {
	return null;
	}

	return qsprintf(
	$conn,
	'id in (%Ld)',
	$this->taskIDs);
	}

	private function buildTaskPHIDsWhereClause(AphrontDatabaseConnection $conn) {
	if (!$this->taskPHIDs) {
	return null;
	}

	return qsprintf(
	$conn,
	'phid in (%Ls)',
	$this->taskPHIDs);
	}

	private function buildStatusWhereClause(AphrontDatabaseConnection $conn) {
	static $map = array(
	self::STATUS_RESOLVED => ManiphestTaskStatus::STATUS_CLOSED_RESOLVED,
	self::STATUS_WONTFIX => ManiphestTaskStatus::STATUS_CLOSED_WONTFIX,
	self::STATUS_INVALID => ManiphestTaskStatus::STATUS_CLOSED_INVALID,
	self::STATUS_SPITE => ManiphestTaskStatus::STATUS_CLOSED_SPITE,
	self::STATUS_DUPLICATE => ManiphestTaskStatus::STATUS_CLOSED_DUPLICATE,
	);

	switch ($this->status) {
	case self::STATUS_ANY:
	return null;
	case self::STATUS_OPEN:
	return qsprintf(
	$conn,
	'status IN (%Ls)',
	ManiphestTaskStatus::getOpenStatusConstants());
	case self::STATUS_CLOSED:
	return qsprintf(
	$conn,
	'status IN (%Ls)',
	ManiphestTaskStatus::getClosedStatusConstants());
	default:
	$constant = idx($map, $this->status);
	if (!$constant) {
	throw new Exception("Unknown status query '{$this->status}'!");
	}
	return qsprintf(
	$conn,
	'status = %s',
	$constant);
	}
	}

	private function buildStatusesWhereClause(AphrontDatabaseConnection $conn) {
	if ($this->statuses) {
	return qsprintf(
	$conn,
	'status IN (%Ls)',
	$this->statuses);
	}
	return null;
	}

	private function buildPrioritiesWhereClause(AphrontDatabaseConnection $conn) {
	if ($this->priorities) {
	return qsprintf(
	$conn,
	'priority IN (%Ld)',
	$this->priorities);
	}

	return null;
	}

	private function buildAuthorWhereClause(AphrontDatabaseConnection $conn) {
	if (!$this->authorPHIDs) {
	return null;
	}

	return qsprintf(
	$conn,
	'authorPHID in (%Ls)',
	$this->authorPHIDs);
	}

	private function buildOwnerWhereClause(AphrontDatabaseConnection $conn) {
	if (!$this->ownerPHIDs) {
	if ($this->includeUnowned === null) {
	return null;
	} else if ($this->includeUnowned) {
	return qsprintf(
	$conn,
	'ownerPHID IS NULL');
	} else {
	return qsprintf(
	$conn,
	'ownerPHID IS NOT NULL');
	}
	}

	if ($this->includeUnowned) {
	return qsprintf(
	$conn,
	'ownerPHID IN (%Ls) OR ownerPHID IS NULL',
	$this->ownerPHIDs);
	} else {
	return qsprintf(
	$conn,
	'ownerPHID IN (%Ls)',
	$this->ownerPHIDs);
	}
	}

	private function buildFullTextWhereClause(AphrontDatabaseConnection $conn) {
	if (!strlen($this->fullTextSearch)) {
	return null;
	}

	// In doing a fulltext search, we first find all the PHIDs that match the
	// fulltext search, and then use that to limit the rest of the search
	$fulltext_query = id(new PhabricatorSavedQuery())
	->setEngineClassName('PhabricatorSearchApplicationSearchEngine')
	->setParameter('query', $this->fullTextSearch);

	// NOTE: Setting this to something larger than 2^53 will raise errors in
	// ElasticSearch, and billions of results won't fit in memory anyway.
	$fulltext_query->setParameter('limit', 100000);
	$fulltext_query->setParameter('type', ManiphestPHIDTypeTask::TYPECONST);

	$engine = PhabricatorSearchEngineSelector::newSelector()->newEngine();
	$fulltext_results = $engine->executeSearch($fulltext_query);

	if (empty($fulltext_results)) {
	$fulltext_results = array(null);
	}

	return qsprintf(
	$conn,
	'phid IN (%Ls)',
	$fulltext_results);
	}

	private function buildSubscriberWhereClause(AphrontDatabaseConnection $conn) {
	if (!$this->subscriberPHIDs) {
	return null;
	}

	return qsprintf(
	$conn,
	'subscriber.subscriberPHID IN (%Ls)',
	$this->subscriberPHIDs);
	}

	private function buildProjectWhereClause(AphrontDatabaseConnection $conn) {
	if (!$this->projectPHIDs && !$this->includeNoProject) {
	return null;
	}

	$parts = array();
	if ($this->projectPHIDs) {
	$parts[] = qsprintf(
	$conn,
	'project.dst in (%Ls)',
	$this->projectPHIDs);
	}
	if ($this->includeNoProject) {
	$parts[] = qsprintf(
	$conn,
	'project.dst IS NULL');
	}

	return '('.implode(') OR (', $parts).')';
	}

	private function buildAnyProjectWhereClause(AphrontDatabaseConnection $conn) {
	if (!$this->anyProjectPHIDs) {
	return null;
	}

	return qsprintf(
	$conn,
	'anyproject.dst IN (%Ls)',
	$this->anyProjectPHIDs);
	}

	private function buildAnyUserProjectWhereClause(
	AphrontDatabaseConnection $conn) {
	if (!$this->anyUserProjectPHIDs) {
	return null;
	}

	$projects = id(new PhabricatorProjectQuery())
	->setViewer($this->getViewer())
	->withMemberPHIDs($this->anyUserProjectPHIDs)
	->execute();
	$any_user_project_phids = mpull($projects, 'getPHID');
	if (!$any_user_project_phids) {
	throw new PhabricatorEmptyQueryException();
	}

	return qsprintf(
	$conn,
	'anyproject.dst IN (%Ls)',
	$any_user_project_phids);
	}

	private function buildXProjectWhereClause(AphrontDatabaseConnection $conn) {
	if (!$this->xprojectPHIDs) {
	return null;
	}

	return qsprintf(
	$conn,
	'xproject.dst IS NULL');
	}

	private function buildCustomOrderClause(AphrontDatabaseConnection $conn) {
	$order = array();

	switch ($this->groupBy) {
	case self::GROUP_NONE:
	break;
	case self::GROUP_PRIORITY:
	$order[] = 'priority';
	break;
	case self::GROUP_OWNER:
	$order[] = 'ownerOrdering';
	break;
	case self::GROUP_STATUS:
	$order[] = 'status';
	break;
	case self::GROUP_PROJECT:
	$order[] = '<group.project>';
	break;
	default:
	throw new Exception("Unknown group query '{$this->groupBy}'!");
	}

	switch ($this->orderBy) {
	case self::ORDER_PRIORITY:
	$order[] = 'priority';
	$order[] = 'subpriority';
	$order[] = 'dateModified';
	break;
	case self::ORDER_CREATED:
	$order[] = 'id';
	break;
	case self::ORDER_MODIFIED:
	$order[] = 'dateModified';
	break;
	case self::ORDER_TITLE:
	$order[] = 'title';
	break;
	default:
	throw new Exception("Unknown order query '{$this->orderBy}'!");
	}

	$order = array_unique($order);

	if (empty($order)) {
	return null;
	}

	$reverse = ($this->getBeforeID() xor $this->getReversePaging());

	foreach ($order as $k => $column) {
	switch ($column) {
	case 'subpriority':
	case 'ownerOrdering':
	case 'title':
	if ($reverse) {
	$order[$k] = "task.{$column} DESC";
	} else {
	$order[$k] = "task.{$column} ASC";
	}
	break;
	case '<group.project>':
	// Put "No Project" at the end of the list.
	if ($reverse) {
	$order[$k] =
	'projectGroupName.indexedObjectName IS NULL DESC, '.
	'projectGroupName.indexedObjectName DESC';
	} else {
	$order[$k] =
	'projectGroupName.indexedObjectName IS NULL ASC, '.
	'projectGroupName.indexedObjectName ASC';
	}
	break;
	default:
	if ($reverse) {
	$order[$k] = "task.{$column} ASC";
	} else {
	$order[$k] = "task.{$column} DESC";
	}
	break;
	}
	}

	return 'ORDER BY '.implode(', ', $order);
	}

	private function buildJoinsClause(AphrontDatabaseConnection $conn_r) {
	$edge_table = PhabricatorEdgeConfig::TABLE_NAME_EDGE;

	$joins = array();

	if ($this->projectPHIDs \|\| $this->includeNoProject) {
	$joins[] = qsprintf(
	$conn_r,
	'%Q JOIN %T project ON project.src = task.phid
	AND project.type = %d',
	($this->includeNoProject ? 'LEFT' : ''),
	$edge_table,
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST);
	}

	if ($this->anyProjectPHIDs \|\| $this->anyUserProjectPHIDs) {
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T anyproject ON anyproject.src = task.phid
	AND anyproject.type = %d',
	$edge_table,
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST);
	}

	if ($this->xprojectPHIDs) {
	$joins[] = qsprintf(
	$conn_r,
	'LEFT JOIN %T xproject ON xproject.src = task.phid
	AND xproject.type = %d
	AND xproject.dst IN (%Ls)',
	$edge_table,
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
	$this->xprojectPHIDs);
	}

	if ($this->subscriberPHIDs) {
	$subscriber_dao = new ManiphestTaskSubscriber();
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T subscriber ON subscriber.taskPHID = task.phid',
	$subscriber_dao->getTableName());
	}

	switch ($this->groupBy) {
	case self::GROUP_PROJECT:
	$ignore_group_phids = $this->getIgnoreGroupedProjectPHIDs();
	if ($ignore_group_phids) {
	$joins[] = qsprintf(
	$conn_r,
	'LEFT JOIN %T projectGroup ON task.phid = projectGroup.src
	AND projectGroup.type = %d
	AND projectGroup.dst NOT IN (%Ls)',
	$edge_table,
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
	$ignore_group_phids);
	} else {
	$joins[] = qsprintf(
	$conn_r,
	'LEFT JOIN %T projectGroup ON task.phid = projectGroup.src
	AND projectGroup.type = %d',
	$edge_table,
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST);
	}
	$joins[] = qsprintf(
	$conn_r,
	'LEFT JOIN %T projectGroupName
	ON projectGroup.dst = projectGroupName.indexedObjectPHID',
	id(new ManiphestNameIndex())->getTableName());
	break;
	}

	$joins[] = $this->buildApplicationSearchJoinClause($conn_r);

	return implode(' ', $joins);
	}

	private function buildGroupClause(AphrontDatabaseConnection $conn_r) {
	$joined_multiple_rows = (count($this->projectPHIDs) > 1) \|\|
	(count($this->anyProjectPHIDs) > 1) \|\|
	($this->getApplicationSearchMayJoinMultipleRows());

	$joined_project_name = ($this->groupBy == self::GROUP_PROJECT);

	// If we're joining multiple rows, we need to group the results by the
	// task IDs.
	if ($joined_multiple_rows) {
	if ($joined_project_name) {
	return 'GROUP BY task.phid, projectGroup.dst';
	} else {
	return 'GROUP BY task.phid';
	}
	} else {
	return '';
	}
	}

	/**
	* Return project PHIDs which we should ignore when grouping tasks by
	* project. For example, if a user issues a query like:
	*
	* Tasks in all projects: Frontend, Bugs
	*
	* ...then we don't show "Frontend" or "Bugs" groups in the result set, since
	* they're meaningless as all results are in both groups.
	*
	* Similarly, for queries like:
	*
	* Tasks in any projects: Public Relations
	*
	* ...we ignore the single project, as every result is in that project. (In
	* the case that there are several "any" projects, we do not ignore them.)
	*
	* @return list<phid> Project PHIDs which should be ignored in query
	* construction.
	*/
	private function getIgnoreGroupedProjectPHIDs() {
	$phids = array();

	if ($this->projectPHIDs) {
	$phids[] = $this->projectPHIDs;
	}

	if (count($this->anyProjectPHIDs) == 1) {
	$phids[] = $this->anyProjectPHIDs;
	}

	// Maybe we should also exclude the "excludeProjectPHIDs"? It won't
	// impact the results, but we might end up with a better query plan.
	// Investigate this on real data? This is likely very rare.

	return array_mergev($phids);
	}

	private function loadCursorObject($id) {
	$results = id(new ManiphestTaskQuery())
	->setViewer($this->getPagingViewer())
	->withIDs(array((int)$id))
	->execute();
	return head($results);
	}

	protected function getPagingValue($result) {
	$id = $result->getID();

	switch ($this->groupBy) {
	case self::GROUP_NONE:
	return $id;
	case self::GROUP_PRIORITY:
	return $id.'.'.$result->getPriority();
	case self::GROUP_OWNER:
	return rtrim($id.'.'.$result->getOwnerPHID(), '.');
	case self::GROUP_STATUS:
	return $id.'.'.$result->getStatus();
	case self::GROUP_PROJECT:
	return rtrim($id.'.'.$result->getGroupByProjectPHID(), '.');
	default:
	throw new Exception("Unknown group query '{$this->groupBy}'!");
	}
	}

	protected function buildPagingClause(AphrontDatabaseConnection $conn_r) {
	$default = parent::buildPagingClause($conn_r);

	$before_id = $this->getBeforeID();
	$after_id = $this->getAfterID();

	if (!$before_id && !$after_id) {
	return $default;
	}

	$cursor_id = nonempty($before_id, $after_id);
	$cursor_parts = explode('.', $cursor_id, 2);
	$task_id = $cursor_parts[0];
	$group_id = idx($cursor_parts, 1);

	$cursor = $this->loadCursorObject($task_id);
	if (!$cursor) {
	return null;
	}

	$columns = array();

	switch ($this->groupBy) {
	case self::GROUP_NONE:
	break;
	case self::GROUP_PRIORITY:
	$columns[] = array(
	'name' => 'task.priority',
	'value' => (int)$group_id,
	'type' => 'int',
	);
	break;
	case self::GROUP_OWNER:
	$columns[] = array(
	'name' => '(task.ownerOrdering IS NULL)',
	'value' => (int)(strlen($group_id) ? 0 : 1),
	'type' => 'int',
	);
	if ($group_id) {
	$paging_users = id(new PhabricatorPeopleQuery())
	->setViewer($this->getViewer())
	->withPHIDs(array($group_id))
	->execute();
	if (!$paging_users) {
	return null;
	}
	$columns[] = array(
	'name' => 'task.ownerOrdering',
	'value' => head($paging_users)->getUsername(),
	'type' => 'string',
	'reverse' => true,
	);
	}
	break;
	case self::GROUP_STATUS:
	$columns[] = array(
	'name' => 'task.status',
	'value' => $group_id,
	'type' => 'string',
	);
	break;
	case self::GROUP_PROJECT:
	$columns[] = array(
	'name' => '(projectGroupName.indexedObjectName IS NULL)',
	'value' => (int)(strlen($group_id) ? 0 : 1),
	'type' => 'int',
	);
	if ($group_id) {
	$paging_projects = id(new PhabricatorProjectQuery())
	->setViewer($this->getViewer())
	->withPHIDs(array($group_id))
	->execute();
	if (!$paging_projects) {
	return null;
	}
	$columns[] = array(
	'name' => 'projectGroupName.indexedObjectName',
	'value' => head($paging_projects)->getName(),
	'type' => 'string',
	'reverse' => true,
	);
	}
	break;
	default:
	throw new Exception("Unknown group query '{$this->groupBy}'!");
	}

	switch ($this->orderBy) {
	case self::ORDER_PRIORITY:
	if ($this->groupBy != self::GROUP_PRIORITY) {
	$columns[] = array(
	'name' => 'task.priority',
	'value' => (int)$cursor->getPriority(),
	'type' => 'int',
	);
	}
	$columns[] = array(
	'name' => 'task.subpriority',
	'value' => (int)$cursor->getSubpriority(),
	'type' => 'int',
	'reverse' => true,
	);
	$columns[] = array(
	'name' => 'task.dateModified',
	'value' => (int)$cursor->getDateModified(),
	'type' => 'int',
	);
	break;
	case self::ORDER_CREATED:
	$columns[] = array(
	'name' => 'task.id',
	'value' => (int)$cursor->getID(),
	'type' => 'int',
	);
	break;
	case self::ORDER_MODIFIED:
	$columns[] = array(
	'name' => 'task.dateModified',
	'value' => (int)$cursor->getDateModified(),
	'type' => 'int',
	);
	break;
	case self::ORDER_TITLE:
	$columns[] = array(
	'name' => 'task.title',
	'value' => $cursor->getTitle(),
	'type' => 'string',
	);
	$columns[] = array(
	'name' => 'task.id',
	'value' => $cursor->getID(),
	'type' => 'int',
	);
	break;
	default:
	throw new Exception("Unknown order query '{$this->orderBy}'!");
	}

	return $this->buildPagingClauseFromMultipleColumns(
	$conn_r,
	$columns,
	array(
	'reversed' => (bool)($before_id xor $this->getReversePaging()),
	));
	}

	protected function getApplicationSearchObjectPHIDColumn() {
	return 'task.phid';
	}

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

	}
	diff --git a/src/applications/maniphest/storage/ManiphestTask.php b/src/applications/maniphest/storage/ManiphestTask.php
	index 9f9d9ca26e..fbba84c01c 100644
	--- a/src/applications/maniphest/storage/ManiphestTask.php
	+++ b/src/applications/maniphest/storage/ManiphestTask.php
	@@ -1,323 +1,325 @@
	<?php

	final class ManiphestTask extends ManiphestDAO
	implements
	PhabricatorMarkupInterface,
	PhabricatorPolicyInterface,
	PhabricatorTokenReceiverInterface,
	PhabricatorFlaggableInterface,
	PhrequentTrackableInterface,
	PhabricatorCustomFieldInterface,
	PhabricatorDestructableInterface,
	PhabricatorApplicationTransactionInterface {

	const MARKUP_FIELD_DESCRIPTION = 'markup:desc';

	protected $authorPHID;
	protected $ownerPHID;
	protected $ccPHIDs = array();

	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 $attached = array();
	protected $projectPHIDs = array();
	private $subscribersNeedUpdate;

	protected $ownerOrdering;

	private $groupByProjectPHID = self::ATTACHABLE;
	private $customFields = self::ATTACHABLE;
	+ private $edgeProjectPHIDs = self::ATTACHABLE;

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

	$view_policy = $app->getPolicy(ManiphestCapabilityDefaultView::CAPABILITY);
	$edit_policy = $app->getPolicy(ManiphestCapabilityDefaultEdit::CAPABILITY);

	return id(new ManiphestTask())
	->setStatus(ManiphestTaskStatus::getDefaultStatus())
	->setPriority(ManiphestTaskPriority::getDefaultPriority())
	->setAuthorPHID($actor->getPHID())
	->setViewPolicy($view_policy)
	- ->setEditPolicy($edit_policy);
	+ ->setEditPolicy($edit_policy)
	+ ->attachProjectPHIDs(array());
	}

	public function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_SERIALIZATION => array(
	'ccPHIDs' => self::SERIALIZATION_JSON,
	'attached' => self::SERIALIZATION_JSON,
	'projectPHIDs' => self::SERIALIZATION_JSON,
	),
	) + parent::getConfiguration();
	}

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

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

	public function getAttachedPHIDs($type) {
	return array_keys(idx($this->attached, $type, array()));
	}

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

	public function getCCPHIDs() {
	return array_values(nonempty($this->ccPHIDs, array()));
	}

	- public function setProjectPHIDs(array $phids) {
	- $this->projectPHIDs = array_values($phids);
	- return $this;
	+ public function getProjectPHIDs() {
	+ return $this->assertAttached($this->edgeProjectPHIDs);
	}

	- public function getProjectPHIDs() {
	- return array_values(nonempty($this->projectPHIDs, array()));
	+ public function attachProjectPHIDs(array $phids) {
	+ $this->edgeProjectPHIDs = $phids;
	+ return $this;
	}

	public function setCCPHIDs(array $phids) {
	$this->ccPHIDs = array_values($phids);
	$this->subscribersNeedUpdate = true;
	return $this;
	}

	public function setOwnerPHID($phid) {
	$this->ownerPHID = nonempty($phid, null);
	$this->subscribersNeedUpdate = true;
	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 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();

	if ($this->subscribersNeedUpdate) {
	// If we've changed the subscriber PHIDs for this task, update the link
	// table.
	ManiphestTaskSubscriber::updateTaskSubscribers($this);
	$this->subscribersNeedUpdate = false;
	}

	return $result;
	}

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

	public function getPrioritySortVector() {
	return array(
	$this->getPriority(),
	-$this->getSubpriority(),
	);
	}


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


	/**
	* @task markup
	*/
	public function getMarkupFieldKey($field) {
	$hash = PhabricatorHash::digest($this->getMarkupText($field));
	$id = $this->getID();
	return "maniphest:T{$id}:{$field}:{$hash}";
	}


	/**
	* @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_EDIT,
	);
	}

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	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;
	}


	/* -( PhabricatorDestructableInterface )----------------------------------- */


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

	$this->openTransaction();

	// TODO: Once this implements PhabricatorTransactionInterface, this
	// will be handled automatically and can be removed.
	$xactions = id(new ManiphestTransaction())->loadAllWhere(
	'objectPHID = %s',
	$this->getPHID());
	foreach ($xactions as $xaction) {
	$engine->destroyObject($xaction);
	}

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


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


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

	public function getApplicationTransactionObject() {
	return $this;
	}

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

	}
	diff --git a/src/applications/maniphest/storage/ManiphestTaskProject.php b/src/applications/maniphest/storage/ManiphestTaskProject.php
	index eda914579b..d5d002466b 100644
	--- a/src/applications/maniphest/storage/ManiphestTaskProject.php
	+++ b/src/applications/maniphest/storage/ManiphestTaskProject.php
	@@ -1,48 +1,49 @@
	<?php

	/**
	* This is a DAO for the Task -> Project table, which denormalizes the
	* relationship between tasks and projects into a link table so it can be
	* efficiently queried. This table is not authoritative; the projectPHIDs field
	* of ManiphestTask is. The rows in this table are regenerated when transactions
	* are applied to tasks which affected their associated projects.
	*/
	final class ManiphestTaskProject extends ManiphestDAO {

	protected $taskPHID;
	protected $projectPHID;

	public function getConfiguration() {
	return array(
	self::CONFIG_IDS => self::IDS_MANUAL,
	self::CONFIG_TIMESTAMPS => false,
	);
	}

	- public static function updateTaskProjects(ManiphestTask $task) {
	+ public static function updateTaskProjects(
	+ ManiphestTask $task,
	+ array $new_phids) {
	+
	$edge_type = PhabricatorProjectObjectHasProjectEdgeType::EDGECONST;

	$old_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$task->getPHID(),
	$edge_type);
	- $new_phids = $task->getProjectPHIDs();

	$add_phids = array_diff($new_phids, $old_phids);
	$rem_phids = array_diff($old_phids, $new_phids);

	if (!$add_phids && !$rem_phids) {
	return;
	}

	-
	$editor = new PhabricatorEdgeEditor();
	foreach ($add_phids as $phid) {
	$editor->addEdge($task->getPHID(), $edge_type, $phid);
	}
	foreach ($rem_phids as $phid) {
	$editor->remEdge($task->getPHID(), $edge_type, $phid);
	}
	$editor->save();
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Jun 9, 11:54 PM (12 h, 46 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 140169
Default Alt Text: (81 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions