No OneTemporary
Actions

Size

32 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/conduit/method/maniphest/base/ConduitAPI_maniphest_Method.php b/src/applications/conduit/method/maniphest/base/ConduitAPI_maniphest_Method.php
	index 517caae2cb..a3dee43da0 100644
	--- a/src/applications/conduit/method/maniphest/base/ConduitAPI_maniphest_Method.php
	+++ b/src/applications/conduit/method/maniphest/base/ConduitAPI_maniphest_Method.php
	@@ -1,214 +1,226 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/**
	* @group conduit
	*/
	abstract class ConduitAPI_maniphest_Method extends ConduitAPIMethod {

	protected function buildTaskInfoDictionary(ManiphestTask $task) {
	$results = $this->buildTaskInfoDictionaries(array($task));
	return idx($results, $task->getPHID());
	}

	protected function getTaskFields($is_new) {
	$fields = array();

	if (!$is_new) {
	$fields += array(
	'id' => 'optional int',
	'phid' => 'optional int',
	);
	}

	$fields += array(
	'title' => $is_new ? 'required string' : 'optional string',
	'description' => 'optional string',
	'ownerPHID' => 'optional phid',
	'ccPHIDs' => 'optional list<phid>',
	'priority' => 'optional int',
	'projectPHIDs' => 'optional list<phid>',
	'filePHIDs' => 'optional list<phid>',
	'auxiliary' => 'optional dict',
	);

	if (!$is_new) {
	$fields += array(
	'status' => 'optional int',
	'comments' => 'optional string',
	);
	}

	return $fields;
	}

	protected function applyRequest(
	ManiphestTask $task,
	ConduitAPIRequest $request,
	$is_new) {

	$changes = array();

	if ($is_new) {
	$task->setTitle((string)$request->getValue('title'));
	$task->setDescription((string)$request->getValue('description'));
	$changes[ManiphestTransactionType::TYPE_STATUS] =
	ManiphestTaskStatus::STATUS_OPEN;
	} else {

	$comments = $request->getValue('comments');
	if (!$is_new && $comments !== null) {
	$changes[ManiphestTransactionType::TYPE_NONE] = null;
	}

	$title = $request->getValue('title');
	if ($title !== null) {
	$changes[ManiphestTransactionType::TYPE_TITLE] = $title;
	}

	$desc = $request->getValue('description');
	if ($desc !== null) {
	$changes[ManiphestTransactionType::TYPE_DESCRIPTION] = $desc;
	}

	$status = $request->getValue('status');
	if ($status !== null) {
	$changes[ManiphestTransactionType::TYPE_STATUS] = $status;
	}
	}

	$priority = $request->getValue('priority');
	if ($priority !== null) {
	$changes[ManiphestTransactionType::TYPE_PRIORITY] = $priority;
	}

	$owner_phid = $request->getValue('ownerPHID');
	if ($owner_phid !== null) {
	$changes[ManiphestTransactionType::TYPE_OWNER] = $owner_phid;
	}

	$ccs = $request->getValue('ccPHIDs');
	if ($ccs !== null) {
	$changes[ManiphestTransactionType::TYPE_CCS] = $ccs;
	}

	$project_phids = $request->getValue('projectPHIDs');
	if ($project_phids !== null) {
	$changes[ManiphestTransactionType::TYPE_PROJECTS] = $project_phids;
	}

	$file_phids = $request->getValue('filePHIDs');
	if ($file_phids !== null) {
	$file_map = array_fill_keys($file_phids, true);
	$attached = $task->getAttached();
	$attached[PhabricatorPHIDConstants::PHID_TYPE_FILE] = $file_map;

	$changes[ManiphestTransactionType::TYPE_ATTACH] = $attached;
	}

	$content_source = PhabricatorContentSource::newForSource(
	PhabricatorContentSource::SOURCE_CONDUIT,
	array());

	$template = new ManiphestTransaction();
	$template->setContentSource($content_source);
	$template->setAuthorPHID($request->getUser()->getPHID());

	$transactions = array();
	foreach ($changes as $type => $value) {
	$transaction = clone $template;
	$transaction->setTransactionType($type);
	$transaction->setNewValue($value);
	if ($type == ManiphestTransactionType::TYPE_NONE) {
	$transaction->setComments($comments);
	}
	$transactions[] = $transaction;
	}

	$auxiliary = $request->getValue('auxiliary');
	if ($auxiliary) {
	$task->loadAndAttachAuxiliaryAttributes();
	foreach ($auxiliary as $aux_key => $aux_value) {
	$transaction = clone $template;
	$transaction->setTransactionType(
	ManiphestTransactionType::TYPE_AUXILIARY);
	$transaction->setMetadataValue('aux:key', $aux_key);
	$transaction->setNewValue($aux_value);
	$transactions[] = $transaction;
	}
	}

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

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

	$editor = new ManiphestTransactionEditor();
	$editor->applyTransactions($task, $transactions);
	+
	+ $event = new PhabricatorEvent(
	+ PhabricatorEventType::TYPE_MANIPHEST_DIDEDITTASK,
	+ array(
	+ 'task' => $task,
	+ 'new' => $is_new,
	+ 'transactions' => $transactions,
	+ ));
	+ $event->setUser($request->getUser());
	+ $event->setConduitRequest($request);
	+ PhutilEventEngine::dispatchEvent($event);
	+
	}

	protected function buildTaskInfoDictionaries(array $tasks) {
	assert_instances_of($tasks, 'ManiphestTask');
	if (!$tasks) {
	return array();
	}

	$all_aux = id(new ManiphestTaskAuxiliaryStorage())->loadAllWhere(
	'taskPHID in (%Ls)',
	mpull($tasks, 'getPHID'));
	$all_aux = mgroup($all_aux, 'getTaskPHID');

	$result = array();
	foreach ($tasks as $task) {
	$auxiliary = idx($all_aux, $task->getPHID(), array());
	$auxiliary = mpull($auxiliary, 'getValue', 'getName');

	$result[$task->getPHID()] = array(
	'id' => $task->getID(),
	'phid' => $task->getPHID(),
	'authorPHID' => $task->getAuthorPHID(),
	'ownerPHID' => $task->getOwnerPHID(),
	'ccPHIDs' => $task->getCCPHIDs(),
	'status' => $task->getStatus(),
	'priority' => ManiphestTaskPriority::getTaskPriorityName(
	$task->getPriority()),
	'title' => $task->getTitle(),
	'description' => $task->getDescription(),
	'projectPHIDs' => $task->getProjectPHIDs(),
	'uri' => PhabricatorEnv::getProductionURI('/T'.$task->getID()),
	'auxiliary' => $auxiliary,

	'objectName' => 'T'.$task->getID(),
	'dateCreated' => $task->getDateCreated(),
	'dateModified' => $task->getDateModified(),
	);
	}

	return $result;
	}

	}
	diff --git a/src/applications/maniphest/controller/taskedit/ManiphestTaskEditController.php b/src/applications/maniphest/controller/taskedit/ManiphestTaskEditController.php
	index c07e0a7820..44b1cd84c8 100644
	--- a/src/applications/maniphest/controller/taskedit/ManiphestTaskEditController.php
	+++ b/src/applications/maniphest/controller/taskedit/ManiphestTaskEditController.php
	@@ -1,543 +1,557 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/**
	* @group maniphest
	*/
	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();

	$files = array();
	$parent_task = null;
	$template_id = null;

	if ($this->id) {
	$task = id(new ManiphestTask())->load($this->id);
	if (!$task) {
	return new Aphront404Response();
	}
	} else {
	$task = new ManiphestTask();
	$task->setPriority(ManiphestTaskPriority::PRIORITY_TRIAGE);
	$task->setAuthorPHID($user->getPHID());

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

	$default_projects = $request->getStr('projects');
	if ($default_projects) {
	$task->setProjectPHIDs(explode(';', $default_projects));
	}
	}

	$file_phids = $request->getArr('files', array());
	if (!$file_phids) {
	// Allow a single 'file' key instead, mostly since Mac OS X urlencodes
	// square brackets in URLs when passed to 'open', so you can't 'open'
	// a URL like '?files[]=xyz' and have PHP interpret it correctly.
	$phid = $request->getStr('file');
	if ($phid) {
	$file_phids = array($phid);
	}
	}

	if ($file_phids) {
	$files = id(new PhabricatorFile())->loadAllWhere(
	'phid IN (%Ls)',
	$file_phids);
	}

	$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 ManiphestTask())->load($parent_id);
	}
	}

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

	$extensions = ManiphestTaskExtensions::newExtensions();
	$aux_fields = $extensions->getAuxiliaryFieldSpecifications();

	if ($request->isFormPost()) {

	$changes = array();

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

	$workflow = '';

	if ($task->getID()) {
	if ($new_title != $task->getTitle()) {
	$changes[ManiphestTransactionType::TYPE_TITLE] = $new_title;
	}
	if ($new_desc != $task->getDescription()) {
	$changes[ManiphestTransactionType::TYPE_DESCRIPTION] = $new_desc;
	}
	if ($new_status != $task->getStatus()) {
	$changes[ManiphestTransactionType::TYPE_STATUS] = $new_status;
	}
	} else {
	$task->setTitle($new_title);
	$task->setDescription($new_desc);
	$changes[ManiphestTransactionType::TYPE_STATUS] =
	ManiphestTaskStatus::STATUS_OPEN;

	$workflow = 'create';
	}

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

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

	foreach ($aux_fields as $aux_field) {
	$aux_field->setValueFromRequest($request);

	if ($aux_field->isRequired() && !strlen($aux_field->getValue())) {
	$errors[] = $aux_field->getLabel() . ' is required.';
	$aux_field->setError('Required');
	}

	if (strlen($aux_field->getValue())) {
	try {
	$aux_field->validate();
	} catch (Exception $e) {
	$errors[] = $e->getMessage();
	$aux_field->setError('Invalid');
	}
	}
	}

	if ($errors) {
	$task->setPriority($request->getInt('priority'));
	$task->setOwnerPHID($owner_phid);
	$task->setCCPHIDs($request->getArr('cc'));
	$task->setProjectPHIDs($request->getArr('projects'));
	} else {
	if ($request->getInt('priority') != $task->getPriority()) {
	$changes[ManiphestTransactionType::TYPE_PRIORITY] =
	$request->getInt('priority');
	}

	if ($owner_phid != $task->getOwnerPHID()) {
	$changes[ManiphestTransactionType::TYPE_OWNER] = $owner_phid;
	}

	if ($request->getArr('cc') != $task->getCCPHIDs()) {
	$changes[ManiphestTransactionType::TYPE_CCS] = $request->getArr('cc');
	}

	$new_proj_arr = $request->getArr('projects');
	$new_proj_arr = array_values($new_proj_arr);
	sort($new_proj_arr);

	$cur_proj_arr = $task->getProjectPHIDs();
	$cur_proj_arr = array_values($cur_proj_arr);
	sort($cur_proj_arr);

	if ($new_proj_arr != $cur_proj_arr) {
	$changes[ManiphestTransactionType::TYPE_PROJECTS] = $new_proj_arr;
	}

	if ($files) {
	$file_map = mpull($files, 'getPHID');
	$file_map = array_fill_keys($file_map, array());
	$changes[ManiphestTransactionType::TYPE_ATTACH] = array(
	PhabricatorPHIDConstants::PHID_TYPE_FILE => $file_map,
	);
	}

	$content_source = PhabricatorContentSource::newForSource(
	PhabricatorContentSource::SOURCE_WEB,
	array(
	'ip' => $request->getRemoteAddr(),
	));

	$template = new ManiphestTransaction();
	$template->setAuthorPHID($user->getPHID());
	$template->setContentSource($content_source);
	$transactions = array();

	foreach ($changes as $type => $value) {
	$transaction = clone $template;
	$transaction->setTransactionType($type);
	$transaction->setNewValue($value);
	$transactions[] = $transaction;
	}

	if ($aux_fields) {
	$task->loadAndAttachAuxiliaryAttributes();
	foreach ($aux_fields as $aux_field) {
	$transaction = clone $template;
	$transaction->setTransactionType(
	ManiphestTransactionType::TYPE_AUXILIARY);
	$aux_key = $aux_field->getAuxiliaryKey();
	$transaction->setMetadataValue('aux:key', $aux_key);
	$transaction->setNewValue($aux_field->getValueForStorage());
	$transactions[] = $transaction;
	}
	}

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

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

	$editor = new ManiphestTransactionEditor();
	$editor->setAuxiliaryFields($aux_fields);
	$editor->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) {
	$type_task = PhabricatorPHIDConstants::PHID_TYPE_TASK;

	// NOTE: It's safe to simply apply this transaction without doing
	// cycle detection because we know the new task has no children.
	$new_value = $parent_task->getAttached();
	$new_value[$type_task][$task->getPHID()] = array();

	$parent_xaction = clone $template;
	$attach_type = ManiphestTransactionType::TYPE_ATTACH;
	$parent_xaction->setTransactionType($attach_type);
	$parent_xaction->setNewValue($new_value);

	$editor = new ManiphestTransactionEditor();
	$editor->setAuxiliaryFields($aux_fields);
	$editor->applyTransactions($parent_task, array($parent_xaction));

	$workflow = $parent_task->getID();
	}

	$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 ManiphestTask())->load($template_id);
	if ($template_task) {
	$task->setCCPHIDs($template_task->getCCPHIDs());
	$task->setProjectPHIDs($template_task->getProjectPHIDs());
	$task->setOwnerPHID($template_task->getOwnerPHID());
	}
	}
	}
	}

	$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 = id(new PhabricatorObjectHandleData($phids))
	->loadHandles($phids);

	$tvalues = mpull($handles, 'getFullName', 'getPHID');

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

	$priority_map = ManiphestTaskPriority::getTaskPriorityMap();

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

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

	if ($task->getProjectPHIDs()) {
	$projects_value = array_select_keys($tvalues, $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 = 'Save Task';
	$header_name = 'Edit Task';
	} else if ($parent_task) {
	$cancel_uri = '/T'.$parent_task->getID();
	$button_name = 'Create Task';
	$header_name = 'Create New Subtask';
	} else {
	$button_name = 'Create Task';
	$header_name = 'Create New Task';
	}

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

	$project_tokenizer_id = celerity_generate_unique_node_id();

	$form = new AphrontFormView();
	$form
	->setUser($user)
	->setAction($request->getRequestURI()->getPath())
	->addHiddenInput('template', $template_id);

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

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

	if ($task->getID()) {
	// Only show this in "edit" mode, not "create" mode, since creating a
	// non-open task is kind of silly and it would just clutter up the
	// "create" interface.
	$form
	->appendChild(
	id(new AphrontFormSelectControl())
	->setLabel('Status')
	->setName('status')
	->setValue($task->getStatus())
	->setOptions(ManiphestTaskStatus::getTaskStatusMap()));
	}

	$form
	->appendChild(
	id(new AphrontFormTokenizerControl())
	->setLabel('Assigned To')
	->setName('assigned_to')
	->setValue($assigned_value)
	->setUser($user)
	->setDatasource('/typeahead/common/users/')
	->setLimit(1))
	->appendChild(
	id(new AphrontFormTokenizerControl())
	->setLabel('CC')
	->setName('cc')
	->setValue($cc_value)
	->setUser($user)
	->setDatasource('/typeahead/common/mailable/'))
	->appendChild(
	id(new AphrontFormSelectControl())
	->setLabel('Priority')
	->setName('priority')
	->setOptions($priority_map)
	->setValue($task->getPriority()))
	->appendChild(
	id(new AphrontFormTokenizerControl())
	->setLabel('Projects')
	->setName('projects')
	->setValue($projects_value)
	->setID($project_tokenizer_id)
	->setCaption(
	javelin_render_tag(
	'a',
	array(
	'href' => '/project/create/',
	'mustcapture' => true,
	'sigil' => 'project-create',
	),
	'Create New Project'))
	->setDatasource('/typeahead/common/projects/'));

	if ($aux_fields) {

	if (!$request->isFormPost()) {
	$task->loadAndAttachAuxiliaryAttributes();
	foreach ($aux_fields as $aux_field) {
	$aux_key = $aux_field->getAuxiliaryKey();
	$value = $task->getAuxiliaryAttribute($aux_key);
	$aux_field->setValueFromStorage($value);
	}
	}

	foreach ($aux_fields as $aux_field) {
	if ($aux_field->isRequired() &&
	!$aux_field->getError() &&
	!$aux_field->getValue()) {
	$aux_field->setError(true);
	}

	$aux_control = $aux_field->renderControl();
	$form->appendChild($aux_control);
	}
	}

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

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

	if ($files) {
	$file_display = array();
	foreach ($files as $file) {
	$file_display[] = phutil_escape_html($file->getName());
	}
	$file_display = implode('<br />', $file_display);

	$form->appendChild(
	id(new AphrontFormMarkupControl())
	->setLabel('Files')
	->setValue($file_display));

	foreach ($files as $ii => $file) {
	$form->addHiddenInput('files['.$ii.']', $file->getPHID());
	}
	}

	$email_create = PhabricatorEnv::getEnvConfig(
	'metamta.maniphest.public-create-email');
	$email_hint = null;
	if (!$task->getID() && $email_create) {
	$email_hint = 'You can also create tasks by sending an email to: '.
	'<tt>'.phutil_escape_html($email_create).'</tt>';
	}

	$panel_id = celerity_generate_unique_node_id();

	$form
	->appendChild(
	id(new AphrontFormTextAreaControl())
	->setLabel('Description')
	->setName('description')
	->setID('description-textarea')
	->setCaption($email_hint)
	->setValue($task->getDescription()));

	if (!$task->getID()) {
	$form
	->appendChild(
	id(new AphrontFormDragAndDropUploadControl())
	->setLabel('Attached Files')
	->setName('files')
	->setDragAndDropTarget($panel_id)
	->setActivatedClass('aphront-panel-view-drag-and-drop'));
	}

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

	$panel = new AphrontPanelView();
	$panel->setWidth(AphrontPanelView::WIDTH_FULL);
	$panel->setHeader($header_name);
	$panel->setID($panel_id);
	$panel->appendChild($form);

	$description_preview_panel =
	'<div class="aphront-panel-preview aphront-panel-preview-full">
	<div class="maniphest-description-preview-header">
	Description Preview
	</div>
	<div id="description-preview">
	<div class="aphront-panel-preview-loading-text">
	Loading preview...
	</div>
	</div>
	</div>';

	Javelin::initBehavior(
	'maniphest-description-preview',
	array(
	'preview' => 'description-preview',
	'textarea' => 'description-textarea',
	'uri' => '/maniphest/task/descriptionpreview/',
	));

	return $this->buildStandardPageResponse(
	array(
	$error_view,
	$panel,
	$description_preview_panel
	),
	array(
	'title' => $header_name,
	));
	}
	}
	diff --git a/src/applications/maniphest/replyhandler/ManiphestReplyHandler.php b/src/applications/maniphest/replyhandler/ManiphestReplyHandler.php
	index f042007dad..52935b44f7 100644
	--- a/src/applications/maniphest/replyhandler/ManiphestReplyHandler.php
	+++ b/src/applications/maniphest/replyhandler/ManiphestReplyHandler.php
	@@ -1,173 +1,184 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/**
	* @group maniphest
	*/
	final class ManiphestReplyHandler extends PhabricatorMailReplyHandler {

	public function validateMailReceiver($mail_receiver) {
	if (!($mail_receiver instanceof ManiphestTask)) {
	throw new Exception("Mail receiver is not a ManiphestTask!");
	}
	}

	public function getPrivateReplyHandlerEmailAddress(
	PhabricatorObjectHandle $handle) {
	return $this->getDefaultPrivateReplyHandlerEmailAddress($handle, 'T');
	}

	public function getPublicReplyHandlerEmailAddress() {
	return $this->getDefaultPublicReplyHandlerEmailAddress('T');
	}

	public function getReplyHandlerDomain() {
	return PhabricatorEnv::getEnvConfig(
	'metamta.maniphest.reply-handler-domain');
	}

	public function getReplyHandlerInstructions() {
	if ($this->supportsReplies()) {
	return "Reply to comment or attach files, or !close, !claim, or ".
	"!unsubscribe.";
	} else {
	return null;
	}
	}

	public function receiveEmail(PhabricatorMetaMTAReceivedMail $mail) {

	// NOTE: We'll drop in here on both the "reply to a task" and "create a
	// new task" workflows! Make sure you test both if you make changes!

	$task = $this->getMailReceiver();

	$is_new_task = !$task->getID();

	$user = $this->getActor();

	$body = $mail->getCleanTextBody();
	$body = trim($body);

	$xactions = array();

	$content_source = PhabricatorContentSource::newForSource(
	PhabricatorContentSource::SOURCE_EMAIL,
	array(
	'id' => $mail->getID(),
	));

	$template = new ManiphestTransaction();
	$template->setContentSource($content_source);
	$template->setAuthorPHID($user->getPHID());

	if ($is_new_task) {
	// If this is a new task, create a "User created this task." transaction
	// and then set the title and description.
	$xaction = clone $template;
	$xaction->setTransactionType(ManiphestTransactionType::TYPE_STATUS);
	$xaction->setNewValue(ManiphestTaskStatus::STATUS_OPEN);
	$xactions[] = $xaction;

	$task->setAuthorPHID($user->getPHID());
	$task->setTitle(nonempty($mail->getSubject(), 'Untitled Task'));
	$task->setDescription($body);

	} else {
	$lines = explode("\n", trim($body));
	$first_line = head($lines);

	$command = null;
	$matches = null;
	if (preg_match('/^!(\w+)/', $first_line, $matches)) {
	$lines = array_slice($lines, 1);
	$body = implode("\n", $lines);
	$body = trim($body);

	$command = $matches[1];
	}

	$ttype = ManiphestTransactionType::TYPE_NONE;
	$new_value = null;
	switch ($command) {
	case 'close':
	$ttype = ManiphestTransactionType::TYPE_STATUS;
	$new_value = ManiphestTaskStatus::STATUS_CLOSED_RESOLVED;
	break;
	case 'claim':
	$ttype = ManiphestTransactionType::TYPE_OWNER;
	$new_value = $user->getPHID();
	break;
	case 'unsubscribe':
	$ttype = ManiphestTransactionType::TYPE_CCS;
	$ccs = $task->getCCPHIDs();
	foreach ($ccs as $k => $phid) {
	if ($phid == $user->getPHID()) {
	unset($ccs[$k]);
	}
	}
	$new_value = array_values($ccs);
	break;
	}

	$xaction = clone $template;
	$xaction->setTransactionType($ttype);
	$xaction->setNewValue($new_value);
	$xaction->setComments($body);

	$xactions[] = $xaction;
	}

	// TODO: We should look at CCs on the mail and add them as CCs.

	$files = $mail->getAttachments();
	if ($files) {
	$file_xaction = clone $template;
	$file_xaction->setTransactionType(ManiphestTransactionType::TYPE_ATTACH);

	$phid_type = PhabricatorPHIDConstants::PHID_TYPE_FILE;
	$new = $task->getAttached();
	foreach ($files as $file_phid) {
	$new[$phid_type][$file_phid] = array();
	}

	$file_xaction->setNewValue($new);
	$xactions[] = $file_xaction;
	}

	$event = new PhabricatorEvent(
	PhabricatorEventType::TYPE_MANIPHEST_WILLEDITTASK,
	array(
	'task' => $task,
	'mail' => $mail,
	'new' => $is_new_task,
	'transactions' => $xactions,
	));
	$event->setUser($user);
	PhutilEventEngine::dispatchEvent($event);

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


	$editor = new ManiphestTransactionEditor();
	$editor->setParentMessageID($mail->getMessageID());
	$editor->applyTransactions($task, $xactions);
	+
	+ $event = new PhabricatorEvent(
	+ PhabricatorEventType::TYPE_MANIPHEST_DIDEDITTASK,
	+ array(
	+ 'task' => $task,
	+ 'new' => $is_new_task,
	+ 'transactions' => $xactions,
	+ ));
	+ $event->setUser($user);
	+ PhutilEventEngine::dispatchEvent($event);
	+
	}

	}
	diff --git a/src/infrastructure/events/constant/type/PhabricatorEventType.php b/src/infrastructure/events/constant/type/PhabricatorEventType.php
	index 9d13a84ea2..c2f96dbe24 100644
	--- a/src/infrastructure/events/constant/type/PhabricatorEventType.php
	+++ b/src/infrastructure/events/constant/type/PhabricatorEventType.php
	@@ -1,25 +1,26 @@
	<?php

	/*
	- * Copyright 2011 Facebook, Inc.
	+ * Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	final class PhabricatorEventType extends PhutilEventType {

	const TYPE_MANIPHEST_WILLEDITTASK = 'maniphest.willEditTask';
	+ const TYPE_MANIPHEST_DIDEDITTASK = 'maniphest.didEditTask';
	const TYPE_DIFFERENTIAL_WILLSENDMAIL = 'differential.willSendMail';
	const TYPE_DIFFERENTIAL_WILLMARKGENERATED = 'differential.willMarkGenerated';

	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Jan 19, 19:37 (1 d, 9 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1128045
Default Alt Text: (32 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions