No OneTemporary
Actions

Size

18 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/calendar/editor/PhabricatorCalendarEventEditEngine.php b/src/applications/calendar/editor/PhabricatorCalendarEventEditEngine.php
	index 17ea7552e9..fef14c13e1 100644
	--- a/src/applications/calendar/editor/PhabricatorCalendarEventEditEngine.php
	+++ b/src/applications/calendar/editor/PhabricatorCalendarEventEditEngine.php
	@@ -1,264 +1,270 @@
	<?php

	final class PhabricatorCalendarEventEditEngine
	extends PhabricatorEditEngine {

	const ENGINECONST = 'calendar.event';

	public function getEngineName() {
	return pht('Calendar Events');
	}

	public function getSummaryHeader() {
	return pht('Configure Calendar Event Forms');
	}

	public function getSummaryText() {
	return pht('Configure how users create and edit events.');
	}

	public function getEngineApplicationClass() {
	return 'PhabricatorCalendarApplication';
	}

	protected function newEditableObject() {
	return PhabricatorCalendarEvent::initializeNewCalendarEvent(
	$this->getViewer());
	}

	protected function newObjectQuery() {
	return new PhabricatorCalendarEventQuery();
	}

	protected function getObjectCreateTitleText($object) {
	return pht('Create New Event');
	}

	protected function getObjectEditTitleText($object) {
	return pht('Edit Event: %s', $object->getName());
	}

	protected function getObjectEditShortText($object) {
	return $object->getMonogram();
	}

	protected function getObjectCreateShortText() {
	return pht('Create Event');
	}

	protected function getObjectName() {
	return pht('Event');
	}

	protected function getObjectViewURI($object) {
	return $object->getURI();
	}

	protected function getEditorURI() {
	return $this->getApplication()->getApplicationURI('event/edit/');
	}

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

	if ($this->getIsCreate()) {
	$invitee_phids = array($viewer->getPHID());
	} else {
	$invitee_phids = $object->getInviteePHIDsForEdit();
	}

	$frequency_options = array(
	PhutilCalendarRecurrenceRule::FREQUENCY_DAILY => pht('Daily'),
	PhutilCalendarRecurrenceRule::FREQUENCY_WEEKLY => pht('Weekly'),
	PhutilCalendarRecurrenceRule::FREQUENCY_MONTHLY => pht('Monthly'),
	PhutilCalendarRecurrenceRule::FREQUENCY_YEARLY => pht('Yearly'),
	);

	$fields = array(
	id(new PhabricatorTextEditField())
	->setKey('name')
	->setLabel(pht('Name'))
	->setDescription(pht('Name of the event.'))
	->setIsRequired(true)
	->setTransactionType(
	PhabricatorCalendarEventNameTransaction::TRANSACTIONTYPE)
	->setConduitDescription(pht('Rename the event.'))
	->setConduitTypeDescription(pht('New event name.'))
	->setValue($object->getName()),
	id(new PhabricatorRemarkupEditField())
	->setKey('description')
	->setLabel(pht('Description'))
	->setDescription(pht('Description of the event.'))
	->setTransactionType(
	PhabricatorCalendarEventDescriptionTransaction::TRANSACTIONTYPE)
	->setConduitDescription(pht('Update the event description.'))
	->setConduitTypeDescription(pht('New event description.'))
	->setValue($object->getDescription()),
	id(new PhabricatorBoolEditField())
	->setKey('cancelled')
	->setOptions(pht('Active'), pht('Cancelled'))
	->setLabel(pht('Cancelled'))
	->setDescription(pht('Cancel the event.'))
	->setTransactionType(
	PhabricatorCalendarEventCancelTransaction::TRANSACTIONTYPE)
	->setIsConduitOnly(true)
	->setConduitDescription(pht('Cancel or restore the event.'))
	->setConduitTypeDescription(pht('True to cancel the event.'))
	->setValue($object->getIsCancelled()),
	id(new PhabricatorUsersEditField())
	->setKey('hostPHID')
	->setAliases(array('host'))
	->setLabel(pht('Host'))
	->setDescription(pht('Host of the event.'))
	->setTransactionType(
	PhabricatorCalendarEventHostTransaction::TRANSACTIONTYPE)
	->setIsConduitOnly($this->getIsCreate())
	->setConduitDescription(pht('Change the host of the event.'))
	->setConduitTypeDescription(pht('New event host.'))
	->setSingleValue($object->getHostPHID()),
	id(new PhabricatorDatasourceEditField())
	->setKey('inviteePHIDs')
	->setAliases(array('invite', 'invitee', 'invitees', 'inviteePHID'))
	->setLabel(pht('Invitees'))
	->setDatasource(new PhabricatorMetaMTAMailableDatasource())
	->setTransactionType(
	PhabricatorCalendarEventInviteTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Users invited to the event.'))
	->setConduitDescription(pht('Change invited users.'))
	->setConduitTypeDescription(pht('New event invitees.'))
	->setValue($invitee_phids)
	->setCommentActionLabel(pht('Change Invitees')),
	);

	if ($this->getIsCreate()) {
	$fields[] = id(new PhabricatorBoolEditField())
	->setKey('isRecurring')
	->setLabel(pht('Recurring'))
	->setOptions(pht('One-Time Event'), pht('Recurring Event'))
	->setTransactionType(
	PhabricatorCalendarEventRecurringTransaction::TRANSACTIONTYPE)
	->setDescription(pht('One time or recurring event.'))
	->setConduitDescription(pht('Make the event recurring.'))
	->setConduitTypeDescription(pht('Mark the event as a recurring event.'))
	->setValue($object->getIsRecurring());


	$rrule = $object->newRecurrenceRule();
	if ($rrule) {
	$frequency = $rrule->getFrequency();
	} else {
	$frequency = null;
	}

	$fields[] = id(new PhabricatorSelectEditField())
	->setKey('frequency')
	->setLabel(pht('Frequency'))
	->setOptions($frequency_options)
	->setTransactionType(
	PhabricatorCalendarEventFrequencyTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Recurring event frequency.'))
	->setConduitDescription(pht('Change the event frequency.'))
	->setConduitTypeDescription(pht('New event frequency.'))
	->setValue($frequency);
	}

	if ($this->getIsCreate() \|\| $object->getIsRecurring()) {
	$fields[] = id(new PhabricatorEpochEditField())
	+ ->setIsLockable(false)
	+ ->setIsDefaultable(false)
	->setAllowNull(true)
	->setKey('until')
	->setLabel(pht('Repeat Until'))
	->setTransactionType(
	PhabricatorCalendarEventUntilDateTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Last instance of the event.'))
	->setConduitDescription(pht('Change when the event repeats until.'))
	->setConduitTypeDescription(pht('New final event time.'))
	->setValue($object->getUntilDateTimeEpoch());
	}

	$fields[] = id(new PhabricatorBoolEditField())
	->setKey('isAllDay')
	->setLabel(pht('All Day'))
	->setOptions(pht('Normal Event'), pht('All Day Event'))
	->setTransactionType(
	PhabricatorCalendarEventAllDayTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Marks this as an all day event.'))
	->setConduitDescription(pht('Make the event an all day event.'))
	->setConduitTypeDescription(pht('Mark the event as an all day event.'))
	->setValue($object->getIsAllDay());

	$fields[] = id(new PhabricatorEpochEditField())
	->setKey('start')
	->setLabel(pht('Start'))
	+ ->setIsLockable(false)
	+ ->setIsDefaultable(false)
	->setTransactionType(
	PhabricatorCalendarEventStartDateTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Start time of the event.'))
	->setConduitDescription(pht('Change the start time of the event.'))
	->setConduitTypeDescription(pht('New event start time.'))
	->setValue($object->getStartDateTimeEpoch());

	$fields[] = id(new PhabricatorEpochEditField())
	->setKey('end')
	->setLabel(pht('End'))
	+ ->setIsLockable(false)
	+ ->setIsDefaultable(false)
	->setTransactionType(
	PhabricatorCalendarEventEndDateTransaction::TRANSACTIONTYPE)
	->setDescription(pht('End time of the event.'))
	->setConduitDescription(pht('Change the end time of the event.'))
	->setConduitTypeDescription(pht('New event end time.'))
	->setValue($object->getEndDateTimeEpoch());

	$fields[] = id(new PhabricatorIconSetEditField())
	->setKey('icon')
	->setLabel(pht('Icon'))
	->setIconSet(new PhabricatorCalendarIconSet())
	->setTransactionType(
	PhabricatorCalendarEventIconTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Event icon.'))
	->setConduitDescription(pht('Change the event icon.'))
	->setConduitTypeDescription(pht('New event icon.'))
	->setValue($object->getIcon());

	return $fields;
	}

	protected function willBuildEditForm($object, array $fields) {
	$all_day_field = idx($fields, 'isAllDay');
	$start_field = idx($fields, 'start');
	$end_field = idx($fields, 'end');

	if ($all_day_field) {
	$is_all_day = $all_day_field->getValueForTransaction();

	$control_ids = array();
	if ($start_field) {
	$control_ids[] = $start_field->getControlID();
	}
	if ($end_field) {
	$control_ids[] = $end_field->getControlID();
	}

	Javelin::initBehavior(
	'event-all-day',
	array(
	'allDayID' => $all_day_field->getControlID(),
	'controlIDs' => $control_ids,
	));

	} else {
	$is_all_day = $object->getIsAllDay();
	}

	if ($is_all_day) {
	if ($start_field) {
	$start_field->setHideTime(true);
	}

	if ($end_field) {
	$end_field->setHideTime(true);
	}
	}



	return $fields;
	}
	}
	diff --git a/src/applications/transactions/storage/PhabricatorEditEngineConfiguration.php b/src/applications/transactions/storage/PhabricatorEditEngineConfiguration.php
	index 38a4fda0a6..e169171f98 100644
	--- a/src/applications/transactions/storage/PhabricatorEditEngineConfiguration.php
	+++ b/src/applications/transactions/storage/PhabricatorEditEngineConfiguration.php
	@@ -1,323 +1,331 @@
	<?php

	final class PhabricatorEditEngineConfiguration
	extends PhabricatorSearchDAO
	implements
	PhabricatorApplicationTransactionInterface,
	PhabricatorPolicyInterface {

	protected $engineKey;
	protected $builtinKey;
	protected $name;
	protected $viewPolicy;
	protected $properties = array();
	protected $isDisabled = 0;
	protected $isDefault = 0;
	protected $isEdit = 0;
	protected $createOrder = 0;
	protected $editOrder = 0;

	private $engine = self::ATTACHABLE;

	const LOCK_VISIBLE = 'visible';
	const LOCK_LOCKED = 'locked';
	const LOCK_HIDDEN = 'hidden';

	public function getTableName() {
	return 'search_editengineconfiguration';
	}

	public static function initializeNewConfiguration(
	PhabricatorUser $actor,
	PhabricatorEditEngine $engine) {

	return id(new PhabricatorEditEngineConfiguration())
	->setEngineKey($engine->getEngineKey())
	->attachEngine($engine)
	->setViewPolicy(PhabricatorPolicies::getMostOpenPolicy());
	}

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

	public function getCreateSortKey() {
	return $this->getSortKey($this->createOrder);
	}

	public function getEditSortKey() {
	return $this->getSortKey($this->editOrder);
	}

	private function getSortKey($order) {
	// Put objects at the bottom by default if they haven't previously been
	// reordered. When they're explicitly reordered, the smallest sort key we
	// assign is 1, so if the object has a value of 0 it means it hasn't been
	// ordered yet.
	if ($order != 0) {
	$group = 'A';
	} else {
	$group = 'B';
	}

	return sprintf(
	"%s%012d%s\0%012d",
	$group,
	$order,
	$this->getName(),
	$this->getID());
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_SERIALIZATION => array(
	'properties' => self::SERIALIZATION_JSON,
	),
	self::CONFIG_COLUMN_SCHEMA => array(
	'engineKey' => 'text64',
	'builtinKey' => 'text64?',
	'name' => 'text255',
	'isDisabled' => 'bool',
	'isDefault' => 'bool',
	'isEdit' => 'bool',
	'createOrder' => 'uint32',
	'editOrder' => 'uint32',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_engine' => array(
	'columns' => array('engineKey', 'builtinKey'),
	'unique' => true,
	),
	'key_default' => array(
	'columns' => array('engineKey', 'isDefault', 'isDisabled'),
	),
	'key_edit' => array(
	'columns' => array('engineKey', 'isEdit', 'isDisabled'),
	),
	),
	) + parent::getConfiguration();
	}

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

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

	public function attachEngine(PhabricatorEditEngine $engine) {
	$this->engine = $engine;
	return $this;
	}

	public function getEngine() {
	return $this->assertAttached($this->engine);
	}

	public function applyConfigurationToFields(
	PhabricatorEditEngine $engine,
	$object,
	array $fields) {
	$fields = mpull($fields, null, 'getKey');

	$is_new = !$object->getID();

	$values = $this->getProperty('defaults', array());
	foreach ($fields as $key => $field) {
	+ if (!$field->getIsDefaultable()) {
	+ continue;
	+ }
	if ($is_new) {
	if (array_key_exists($key, $values)) {
	$field->readDefaultValueFromConfiguration($values[$key]);
	}
	}
	}

	$locks = $this->getFieldLocks();
	foreach ($fields as $field) {
	$key = $field->getKey();
	switch (idx($locks, $key)) {
	case self::LOCK_LOCKED:
	$field->setIsHidden(false);
	$field->setIsLocked(true);
	break;
	case self::LOCK_HIDDEN:
	$field->setIsHidden(true);
	$field->setIsLocked(false);
	break;
	case self::LOCK_VISIBLE:
	$field->setIsHidden(false);
	$field->setIsLocked(false);
	break;
	default:
	// If we don't have an explicit value, don't make any adjustments.
	break;
	}
	}

	+ // If the field isn't lockable, remove any lock we applied.
	+ if (!$field->getIsLockable()) {
	+ $field->setIsLocked(false);
	+ }
	+
	$fields = $this->reorderFields($fields);

	$preamble = $this->getPreamble();
	if (strlen($preamble)) {
	$fields = array(
	'config.preamble' => id(new PhabricatorInstructionsEditField())
	->setKey('config.preamble')
	->setIsReorderable(false)
	->setIsDefaultable(false)
	->setIsLockable(false)
	->setValue($preamble),
	) + $fields;
	}

	return $fields;
	}

	private function reorderFields(array $fields) {
	// Fields which can not be reordered are fixed in order at the top of the
	// form. These are used to show instructions or contextual information.

	$fixed = array();
	foreach ($fields as $key => $field) {
	if (!$field->getIsReorderable()) {
	$fixed[$key] = $field;
	}
	}

	$keys = $this->getFieldOrder();

	$fields = $fixed + array_select_keys($fields, $keys) + $fields;

	return $fields;
	}

	public function getURI() {
	$engine_key = $this->getEngineKey();
	$key = $this->getIdentifier();

	return "/transactions/editengine/{$engine_key}/view/{$key}/";
	}

	public function getIdentifier() {
	$key = $this->getID();
	if (!$key) {
	$key = $this->getBuiltinKey();
	}
	return $key;
	}

	public function getDisplayName() {
	$name = $this->getName();
	if (strlen($name)) {
	return $name;
	}

	$builtin = $this->getBuiltinKey();
	if ($builtin !== null) {
	return pht('Builtin Form "%s"', $builtin);
	}

	return pht('Untitled Form');
	}

	public function getPreamble() {
	return $this->getProperty('preamble');
	}

	public function setPreamble($preamble) {
	return $this->setProperty('preamble', $preamble);
	}

	public function setFieldOrder(array $field_order) {
	return $this->setProperty('order', $field_order);
	}

	public function getFieldOrder() {
	return $this->getProperty('order', array());
	}

	public function setFieldLocks(array $field_locks) {
	return $this->setProperty('locks', $field_locks);
	}

	public function getFieldLocks() {
	return $this->getProperty('locks', array());
	}

	public function getFieldDefault($key) {
	$defaults = $this->getProperty('defaults', array());
	return idx($defaults, $key);
	}

	public function setFieldDefault($key, $value) {
	$defaults = $this->getProperty('defaults', array());
	$defaults[$key] = $value;
	return $this->setProperty('defaults', $defaults);
	}

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


	/* -( PhabricatorPolicyInterface )----------------------------------------- */


	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->getEngine()
	->getApplication()
	->getPolicy($capability);
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return PhabricatorPolicyFilter::hasCapability(
	$viewer,
	$this->getEngine()->getApplication(),
	PhabricatorPolicyCapability::CAN_EDIT);
	}

	return false;
	}

	public function describeAutomaticCapability($capability) {
	return null;
	}


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


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

	public function getApplicationTransactionObject() {
	return $this;
	}

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

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

	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Jan 19, 12:25 (3 w, 4 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1124547
Default Alt Text: (18 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions