Move into nested docroot

web/core/modules/datetime/src/Plugin/Field/FieldFormatter/DateTimeCustomFormatter.php

@@ -0,0 +1,102 @@
+<?php
+
+namespace Drupal\datetime\Plugin\Field\FieldFormatter;
+
+use Drupal\Core\Datetime\DrupalDateTime;
+use Drupal\Core\Field\FieldItemListInterface;
+use Drupal\Core\Form\FormStateInterface;
+
+/**
+ * Plugin implementation of the 'Custom' formatter for 'datetime' fields.
+ *
+ * @FieldFormatter(
+ *   id = "datetime_custom",
+ *   label = @Translation("Custom"),
+ *   field_types = {
+ *     "datetime"
+ *   }
+ *)
+ */
+class DateTimeCustomFormatter extends DateTimeFormatterBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function defaultSettings() {
+    return array(
+      'date_format' => DATETIME_DATETIME_STORAGE_FORMAT,
+    ) + parent::defaultSettings();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function viewElements(FieldItemListInterface $items, $langcode) {
+    $elements = array();
+
+    foreach ($items as $delta => $item) {
+      $output = '';
+      if (!empty($item->date)) {
+        /** @var \Drupal\Core\Datetime\DrupalDateTime $date */
+        $date = $item->date;
+
+        if ($this->getFieldSetting('datetime_type') == 'date') {
+          // A date without time will pick up the current time, use the default.
+          datetime_date_default_time($date);
+        }
+        $this->setTimeZone($date);
+
+        $output = $this->formatDate($date);
+      }
+      $elements[$delta] = [
+        '#markup' => $output,
+        '#cache' => [
+          'contexts' => [
+            'timezone',
+          ],
+        ],
+      ];
+    }
+
+    return $elements;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function formatDate($date) {
+    $format = $this->getSetting('date_format');
+    $timezone = $this->getSetting('timezone_override');
+    return $this->dateFormatter->format($date->getTimestamp(), 'custom', $format, $timezone != '' ? $timezone : NULL);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function settingsForm(array $form, FormStateInterface $form_state) {
+    $form = parent::settingsForm($form, $form_state);
+
+    $form['date_format'] = array(
+      '#type' => 'textfield',
+      '#title' => $this->t('Date/time format'),
+      '#description' => $this->t('See <a href="http://php.net/manual/function.date.php" target="_blank">the documentation for PHP date formats</a>.'),
+      '#default_value' => $this->getSetting('date_format'),
+    );
+
+    return $form;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function settingsSummary() {
+    $summary = parent::settingsSummary();
+
+    $date = new DrupalDateTime();
+    $this->setTimeZone($date);
+    $summary[] = $date->format($this->getSetting('date_format'), $this->getFormatSettings());
+
+    return $summary;
+  }
+
+}

web/core/modules/datetime/src/Plugin/Field/FieldFormatter/DateTimeDefaultFormatter.php

@@ -0,0 +1,130 @@
+<?php
+
+namespace Drupal\datetime\Plugin\Field\FieldFormatter;
+
+use Drupal\Core\Datetime\DrupalDateTime;
+use Drupal\Core\Field\FieldItemListInterface;
+use Drupal\Core\Form\FormStateInterface;
+
+/**
+ * Plugin implementation of the 'Default' formatter for 'datetime' fields.
+ *
+ * @FieldFormatter(
+ *   id = "datetime_default",
+ *   label = @Translation("Default"),
+ *   field_types = {
+ *     "datetime"
+ *   }
+ * )
+ */
+class DateTimeDefaultFormatter extends DateTimeFormatterBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function defaultSettings() {
+    return array(
+      'format_type' => 'medium',
+    ) + parent::defaultSettings();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function viewElements(FieldItemListInterface $items, $langcode) {
+    $elements = array();
+
+    foreach ($items as $delta => $item) {
+      $output = '';
+      $iso_date = '';
+
+      if ($item->date) {
+        /** @var \Drupal\Core\Datetime\DrupalDateTime $date */
+        $date = $item->date;
+
+        if ($this->getFieldSetting('datetime_type') == 'date') {
+          // A date without time will pick up the current time, use the default.
+          datetime_date_default_time($date);
+        }
+
+        // Create the ISO date in Universal Time.
+        $iso_date = $date->format("Y-m-d\TH:i:s") . 'Z';
+
+        $this->setTimeZone($date);
+
+        $output = $this->formatDate($date);
+      }
+
+      // Display the date using theme datetime.
+      $elements[$delta] = array(
+        '#cache' => [
+          'contexts' => [
+            'timezone',
+          ],
+        ],
+        '#theme' => 'time',
+        '#text' => $output,
+        '#html' => FALSE,
+        '#attributes' => array(
+          'datetime' => $iso_date,
+        ),
+      );
+      if (!empty($item->_attributes)) {
+        $elements[$delta]['#attributes'] += $item->_attributes;
+        // Unset field item attributes since they have been included in the
+        // formatter output and should not be rendered in the field template.
+        unset($item->_attributes);
+      }
+    }
+
+    return $elements;
+
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function formatDate($date) {
+    $format_type = $this->getSetting('format_type');
+    $timezone = $this->getSetting('timezone_override') ?: $date->getTimezone()->getName();
+    return $this->dateFormatter->format($date->getTimestamp(), $format_type, '', $timezone != '' ? $timezone : NULL);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function settingsForm(array $form, FormStateInterface $form_state) {
+    $form = parent::settingsForm($form, $form_state);
+
+    $time = new DrupalDateTime();
+    $format_types = $this->dateFormatStorage->loadMultiple();
+    $options = [];
+    foreach ($format_types as $type => $type_info) {
+      $format = $this->dateFormatter->format($time->format('U'), $type);
+      $options[$type] = $type_info->label() . ' (' . $format . ')';
+    }
+
+    $form['format_type'] = array(
+      '#type' => 'select',
+      '#title' => t('Date format'),
+      '#description' => t("Choose a format for displaying the date. Be sure to set a format appropriate for the field, i.e. omitting time for a field that only has a date."),
+      '#options' => $options,
+      '#default_value' => $this->getSetting('format_type'),
+    );
+
+    return $form;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function settingsSummary() {
+    $summary = parent::settingsSummary();
+
+    $date = new DrupalDateTime();
+    $summary[] = t('Format: @display', array('@display' => $this->formatDate($date, $this->getFormatSettings())));
+
+    return $summary;
+  }
+
+}

web/core/modules/datetime/src/Plugin/Field/FieldFormatter/DateTimeFormatterBase.php

@@ -0,0 +1,170 @@
+<?php
+
+namespace Drupal\datetime\Plugin\Field\FieldFormatter;
+
+use Drupal\Core\Datetime\DateFormatterInterface;
+use Drupal\Core\Datetime\DrupalDateTime;
+use Drupal\Core\Entity\EntityStorageInterface;
+use Drupal\Core\Field\FieldDefinitionInterface;
+use Drupal\Core\Field\FormatterBase;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
+use Drupal\datetime\Plugin\Field\FieldType\DateTimeItem;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+
+/**
+ * Base class for 'DateTime Field formatter' plugin implementations.
+ */
+abstract class DateTimeFormatterBase extends FormatterBase implements ContainerFactoryPluginInterface {
+
+  /**
+   * The date formatter service.
+   *
+   * @var \Drupal\Core\Datetime\DateFormatterInterface
+   */
+  protected $dateFormatter;
+
+  /**
+   * The date format entity storage.
+   *
+   * @var \Drupal\Core\Entity\EntityStorageInterface
+   */
+  protected $dateFormatStorage;
+
+  /**
+   * Constructs a new DateTimeDefaultFormatter.
+   *
+   * @param string $plugin_id
+   *   The plugin_id for the formatter.
+   * @param mixed $plugin_definition
+   *   The plugin implementation definition.
+   * @param \Drupal\Core\Field\FieldDefinitionInterface $field_definition
+   *   The definition of the field to which the formatter is associated.
+   * @param array $settings
+   *   The formatter settings.
+   * @param string $label
+   *   The formatter label display setting.
+   * @param string $view_mode
+   *   The view mode.
+   * @param array $third_party_settings
+   *   Third party settings.
+   * @param \Drupal\Core\Datetime\DateFormatterInterface $date_formatter
+   *   The date formatter service.
+   * @param \Drupal\Core\Entity\EntityStorageInterface $date_format_storage
+   *   The date format entity storage.
+   */
+  public function __construct($plugin_id, $plugin_definition, FieldDefinitionInterface $field_definition, array $settings, $label, $view_mode, array $third_party_settings, DateFormatterInterface $date_formatter, EntityStorageInterface $date_format_storage) {
+    parent::__construct($plugin_id, $plugin_definition, $field_definition, $settings, $label, $view_mode, $third_party_settings);
+
+    $this->dateFormatter = $date_formatter;
+    $this->dateFormatStorage = $date_format_storage;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
+    return new static(
+      $plugin_id,
+      $plugin_definition,
+      $configuration['field_definition'],
+      $configuration['settings'],
+      $configuration['label'],
+      $configuration['view_mode'],
+      $configuration['third_party_settings'],
+      $container->get('date.formatter'),
+      $container->get('entity.manager')->getStorage('date_format')
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function defaultSettings() {
+    return array(
+      'timezone_override' => '',
+    ) + parent::defaultSettings();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function settingsForm(array $form, FormStateInterface $form_state) {
+    $form = parent::settingsForm($form, $form_state);
+
+    $form['timezone_override'] = array(
+      '#type' => 'select',
+      '#title' => $this->t('Time zone override'),
+      '#description' => $this->t('The time zone selected here will always be used'),
+      '#options' => system_time_zones(TRUE),
+      '#default_value' => $this->getSetting('timezone_override'),
+    );
+
+    return $form;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function settingsSummary() {
+    $summary = parent::settingsSummary();
+
+    if ($override = $this->getSetting('timezone_override')) {
+      $summary[] = $this->t('Time zone: @timezone', array('@timezone' => $override));
+    }
+
+    return $summary;
+  }
+
+  /**
+   * Creates a formatted date value as a string.
+   *
+   * @param object $date
+   *   A date object.
+   *
+   * @return string
+   *   A formatted date string using the chosen format.
+   */
+  abstract protected function formatDate($date);
+
+  /**
+   * Sets the proper time zone on a DrupalDateTime object for the current user.
+   *
+   * A DrupalDateTime object loaded from the database will have the UTC time
+   * zone applied to it.  This method will apply the time zone for the current
+   * user, based on system and user settings.
+   *
+   * @see drupal_get_user_timezone()
+   *
+   * @param \Drupal\Core\Datetime\DrupalDateTime $date
+   *   A DrupalDateTime object.
+   */
+  protected function setTimeZone(DrupalDateTime $date) {
+    if ($this->getFieldSetting('datetime_type') === DateTimeItem::DATETIME_TYPE_DATE) {
+      // A date without time has no timezone conversion.
+      $timezone = DATETIME_STORAGE_TIMEZONE;
+    }
+    else {
+      $timezone = drupal_get_user_timezone();
+    }
+    $date->setTimeZone(timezone_open($timezone));
+  }
+
+  /**
+   * Gets a settings array suitable for DrupalDateTime::format().
+   *
+   * @return array
+   *   The settings array that can be passed to DrupalDateTime::format().
+   */
+  protected function getFormatSettings() {
+    $settings = [];
+
+    if ($this->getSetting('timezone_override') != '') {
+      $settings['timezone'] = $this->getSetting('timezone_override');
+    }
+
+    return $settings;
+  }
+
+}

web/core/modules/datetime/src/Plugin/Field/FieldFormatter/DateTimePlainFormatter.php

@@ -0,0 +1,63 @@
+<?php
+
+namespace Drupal\datetime\Plugin\Field\FieldFormatter;
+
+use Drupal\Core\Field\FieldItemListInterface;
+use Drupal\datetime\Plugin\Field\FieldType\DateTimeItem;
+
+/**
+ * Plugin implementation of the 'Plain' formatter for 'datetime' fields.
+ *
+ * @FieldFormatter(
+ *   id = "datetime_plain",
+ *   label = @Translation("Plain"),
+ *   field_types = {
+ *     "datetime"
+ *   }
+ *)
+ */
+class DateTimePlainFormatter extends DateTimeFormatterBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function viewElements(FieldItemListInterface $items, $langcode) {
+    $elements = array();
+
+    foreach ($items as $delta => $item) {
+      $output = '';
+      if (!empty($item->date)) {
+        /** @var \Drupal\Core\Datetime\DrupalDateTime $date */
+        $date = $item->date;
+
+        if ($this->getFieldSetting('datetime_type') == 'date') {
+          // A date without time will pick up the current time, use the default.
+          datetime_date_default_time($date);
+        }
+        $this->setTimeZone($date);
+
+        $output = $this->formatDate($date);
+      }
+      $elements[$delta] = [
+        '#cache' => [
+          'contexts' => [
+            'timezone',
+          ],
+        ],
+        '#markup' => $output,
+      ];
+    }
+
+    return $elements;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function formatDate($date) {
+    $format = $this->getFieldSetting('datetime_type') == DateTimeItem::DATETIME_TYPE_DATE ? DATETIME_DATE_STORAGE_FORMAT : DATETIME_DATETIME_STORAGE_FORMAT;
+    $timezone = $this->getSetting('timezone_override');
+    return $this->dateFormatter->format($date->getTimestamp(), 'custom', $format, $timezone != '' ? $timezone : NULL);
+  }
+
+}

web/core/modules/datetime/src/Plugin/Field/FieldFormatter/DateTimeTimeAgoFormatter.php

@@ -0,0 +1,202 @@
+<?php
+
+namespace Drupal\datetime\Plugin\Field\FieldFormatter;
+
+use Drupal\Component\Utility\SafeMarkup;
+use Drupal\Core\Cache\CacheableMetadata;
+use Drupal\Core\Datetime\DateFormatterInterface;
+use Drupal\Core\Datetime\DrupalDateTime;
+use Drupal\Core\Field\FieldDefinitionInterface;
+use Drupal\Core\Field\FieldItemListInterface;
+use Drupal\Core\Field\FormatterBase;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * Plugin implementation of the 'Time ago' formatter for 'datetime' fields.
+ *
+ * @FieldFormatter(
+ *   id = "datetime_time_ago",
+ *   label = @Translation("Time ago"),
+ *   field_types = {
+ *     "datetime"
+ *   }
+ * )
+ */
+class DateTimeTimeAgoFormatter extends FormatterBase implements ContainerFactoryPluginInterface {
+
+  /**
+   * The date formatter service.
+   *
+   * @var \Drupal\Core\Datetime\DateFormatterInterface
+   */
+  protected $dateFormatter;
+
+  /**
+   * The current Request object.
+   *
+   * @var \Symfony\Component\HttpFoundation\Request
+   */
+  protected $request;
+
+  /**
+   * Constructs a DateTimeTimeAgoFormatter object.
+   *
+   * @param string $plugin_id
+   *   The plugin_id for the formatter.
+   * @param mixed $plugin_definition
+   *   The plugin implementation definition.
+   * @param \Drupal\Core\Field\FieldDefinitionInterface $field_definition
+   *   The definition of the field to which the formatter is associated.
+   * @param array $settings
+   *   The formatter settings.
+   * @param string $label
+   *   The formatter label display setting.
+   * @param string $view_mode
+   *   The view mode.
+   * @param array $third_party_settings
+   *   Third party settings.
+   * @param \Drupal\Core\Datetime\DateFormatterInterface $date_formatter
+   *   The date formatter service.
+   * @param \Symfony\Component\HttpFoundation\Request $request
+   *   The current request.
+   */
+  public function __construct($plugin_id, $plugin_definition, FieldDefinitionInterface $field_definition, array $settings, $label, $view_mode, array $third_party_settings, DateFormatterInterface $date_formatter, Request $request) {
+    parent::__construct($plugin_id, $plugin_definition, $field_definition, $settings, $label, $view_mode, $third_party_settings);
+
+    $this->dateFormatter = $date_formatter;
+    $this->request = $request;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function defaultSettings() {
+    $settings = array(
+      'future_format' => '@interval hence',
+      'past_format' => '@interval ago',
+      'granularity' => 2,
+    ) + parent::defaultSettings();
+
+    return $settings;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
+    return new static(
+      $plugin_id,
+      $plugin_definition,
+      $configuration['field_definition'],
+      $configuration['settings'],
+      $configuration['label'],
+      $configuration['view_mode'],
+      $configuration['third_party_settings'],
+      $container->get('date.formatter'),
+      $container->get('request_stack')->getCurrentRequest()
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function viewElements(FieldItemListInterface $items, $langcode) {
+    $elements = array();
+
+    foreach ($items as $delta => $item) {
+      $date = $item->date;
+      $output = [];
+      if (!empty($item->date)) {
+        if ($this->getFieldSetting('datetime_type') == 'date') {
+          // A date without time will pick up the current time, use the default.
+          datetime_date_default_time($date);
+        }
+        $output = $this->formatDate($date);
+      }
+      $elements[$delta] = $output;
+    }
+
+    return $elements;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function settingsForm(array $form, FormStateInterface $form_state) {
+    $form = parent::settingsForm($form, $form_state);
+
+    $form['future_format'] = array(
+      '#type' => 'textfield',
+      '#title' => $this->t('Future format'),
+      '#default_value' => $this->getSetting('future_format'),
+      '#description' => $this->t('Use <em>@interval</em> where you want the formatted interval text to appear.'),
+    );
+
+    $form['past_format'] = array(
+      '#type' => 'textfield',
+      '#title' => $this->t('Past format'),
+      '#default_value' => $this->getSetting('past_format'),
+      '#description' => $this->t('Use <em>@interval</em> where you want the formatted interval text to appear.'),
+    );
+
+    $form['granularity'] = array(
+      '#type' => 'number',
+      '#title' => $this->t('Granularity'),
+      '#default_value' => $this->getSetting('granularity'),
+      '#description' => $this->t('How many time units should be shown in the formatted output.'),
+    );
+
+    return $form;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function settingsSummary() {
+    $summary = parent::settingsSummary();
+
+    $future_date = new DrupalDateTime('1 year 1 month 1 week 1 day 1 hour 1 minute');
+    $past_date = new DrupalDateTime('-1 year -1 month -1 week -1 day -1 hour -1 minute');
+    $summary[] = t('Future date: %display', array('%display' => $this->formatDate($future_date)));
+    $summary[] = t('Past date: %display', array('%display' => $this->formatDate($past_date)));
+
+    return $summary;
+  }
+
+  /**
+   * Formats a date/time as a time interval.
+   *
+   * @param \Drupal\Core\Datetime\DrupalDateTime|object $date
+   *   A date/time object.
+   *
+   * @return array
+   *   The formatted date/time string using the past or future format setting.
+   */
+  protected function formatDate(DrupalDateTime $date) {
+    $granularity = $this->getSetting('granularity');
+    $timestamp = $date->getTimestamp();
+    $options = [
+      'granularity' => $granularity,
+      'return_as_object' => TRUE,
+    ];
+
+    if ($this->request->server->get('REQUEST_TIME') > $timestamp) {
+      $result = $this->dateFormatter->formatTimeDiffSince($timestamp, $options);
+      $build = [
+        '#markup' => SafeMarkup::format($this->getSetting('past_format'), ['@interval' => $result->getString()]),
+      ];
+    }
+    else {
+      $result = $this->dateFormatter->formatTimeDiffUntil($timestamp, $options);
+      $build = [
+        '#markup' => SafeMarkup::format($this->getSetting('future_format'), ['@interval' => $result->getString()]),
+      ];
+    }
+    CacheableMetadata::createFromObject($result)->applyTo($build);
+    return $build;
+  }
+
+}

web/core/modules/datetime/src/Plugin/Field/FieldType/DateTimeFieldItemList.php

@@ -0,0 +1,121 @@
+<?php
+
+namespace Drupal\datetime\Plugin\Field\FieldType;
+
+use Drupal\Core\Datetime\DrupalDateTime;
+use Drupal\Core\Entity\FieldableEntityInterface;
+use Drupal\Core\Field\FieldDefinitionInterface;
+use Drupal\Core\Field\FieldItemList;
+use Drupal\Core\Form\FormStateInterface;
+
+/**
+ * Represents a configurable entity datetime field.
+ */
+class DateTimeFieldItemList extends FieldItemList {
+
+  /**
+   * Defines the default value as now.
+   */
+  const DEFAULT_VALUE_NOW = 'now';
+
+  /**
+   * Defines the default value as relative.
+   */
+  const DEFAULT_VALUE_CUSTOM = 'relative';
+
+  /**
+   * {@inheritdoc}
+   */
+  public function defaultValuesForm(array &$form, FormStateInterface $form_state) {
+    if (empty($this->getFieldDefinition()->getDefaultValueCallback())) {
+      $default_value = $this->getFieldDefinition()->getDefaultValueLiteral();
+
+      $element = array(
+        '#parents' => array('default_value_input'),
+        'default_date_type' => array(
+          '#type' => 'select',
+          '#title' => t('Default date'),
+          '#description' => t('Set a default value for this date.'),
+          '#default_value' => isset($default_value[0]['default_date_type']) ? $default_value[0]['default_date_type'] : '',
+          '#options' => array(
+            static::DEFAULT_VALUE_NOW => t('Current date'),
+            static::DEFAULT_VALUE_CUSTOM => t('Relative date'),
+          ),
+          '#empty_value' => '',
+        ),
+        'default_date' => array(
+          '#type' => 'textfield',
+          '#title' => t('Relative default value'),
+          '#description' => t("Describe a time by reference to the current day, like '+90 days' (90 days from the day the field is created) or '+1 Saturday' (the next Saturday). See <a href=\"http://php.net/manual/function.strtotime.php\">strtotime</a> for more details."),
+          '#default_value' => (isset($default_value[0]['default_date_type']) && $default_value[0]['default_date_type'] == static::DEFAULT_VALUE_CUSTOM) ? $default_value[0]['default_date'] : '',
+          '#states' => array(
+            'visible' => array(
+              ':input[id="edit-default-value-input-default-date-type"]' => array('value' => static::DEFAULT_VALUE_CUSTOM),
+            )
+          )
+        )
+      );
+
+      return $element;
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function defaultValuesFormValidate(array $element, array &$form, FormStateInterface $form_state) {
+    if ($form_state->getValue(['default_value_input', 'default_date_type']) == static::DEFAULT_VALUE_CUSTOM) {
+      $is_strtotime = @strtotime($form_state->getValue(array('default_value_input', 'default_date')));
+      if (!$is_strtotime) {
+        $form_state->setErrorByName('default_value_input][default_date', t('The relative date value entered is invalid.'));
+      }
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function defaultValuesFormSubmit(array $element, array &$form, FormStateInterface $form_state) {
+    if ($form_state->getValue(array('default_value_input', 'default_date_type'))) {
+      if ($form_state->getValue(array('default_value_input', 'default_date_type')) == static::DEFAULT_VALUE_NOW) {
+        $form_state->setValueForElement($element['default_date'], static::DEFAULT_VALUE_NOW);
+      }
+      return array($form_state->getValue('default_value_input'));
+    }
+    return array();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function processDefaultValue($default_value, FieldableEntityInterface $entity, FieldDefinitionInterface $definition) {
+    $default_value = parent::processDefaultValue($default_value, $entity, $definition);
+
+    if (isset($default_value[0]['default_date_type'])) {
+      if ($definition->getSetting('datetime_type') === DateTimeItem::DATETIME_TYPE_DATE) {
+        // A default date only value should be in the format used for date
+        // storage but in the user's local timezone.
+        $date = new DrupalDateTime($default_value[0]['default_date'], drupal_get_user_timezone());
+        $format = DATETIME_DATE_STORAGE_FORMAT;
+      }
+      else {
+        // A default date+time value should be in the format and timezone used
+        // for date storage.
+        $date = new DrupalDateTime($default_value[0]['default_date'], DATETIME_STORAGE_TIMEZONE);
+        $format = DATETIME_DATETIME_STORAGE_FORMAT;
+      }
+      $value = $date->format($format);
+      // We only provide a default value for the first item, as do all fields.
+      // Otherwise, there is no way to clear out unwanted values on multiple value
+      // fields.
+      $default_value = array(
+        array(
+          'value' => $value,
+          'date' => $date,
+        )
+      );
+    }
+    return $default_value;
+  }
+
+}

web/core/modules/datetime/src/Plugin/Field/FieldType/DateTimeItem.php

@@ -0,0 +1,138 @@
+<?php
+
+namespace Drupal\datetime\Plugin\Field\FieldType;
+
+use Drupal\Core\Field\FieldDefinitionInterface;
+use Drupal\Core\Field\FieldStorageDefinitionInterface;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\Core\TypedData\DataDefinition;
+use Drupal\Core\Field\FieldItemBase;
+
+/**
+ * Plugin implementation of the 'datetime' field type.
+ *
+ * @FieldType(
+ *   id = "datetime",
+ *   label = @Translation("Date"),
+ *   description = @Translation("Create and store date values."),
+ *   default_widget = "datetime_default",
+ *   default_formatter = "datetime_default",
+ *   list_class = "\Drupal\datetime\Plugin\Field\FieldType\DateTimeFieldItemList"
+ * )
+ */
+class DateTimeItem extends FieldItemBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function defaultStorageSettings() {
+    return array(
+      'datetime_type' => 'datetime',
+    ) + parent::defaultStorageSettings();
+  }
+
+  /**
+   * Value for the 'datetime_type' setting: store only a date.
+   */
+  const DATETIME_TYPE_DATE = 'date';
+
+  /**
+   * Value for the 'datetime_type' setting: store a date and time.
+   */
+  const DATETIME_TYPE_DATETIME = 'datetime';
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function propertyDefinitions(FieldStorageDefinitionInterface $field_definition) {
+    $properties['value'] = DataDefinition::create('datetime_iso8601')
+      ->setLabel(t('Date value'))
+      ->setRequired(TRUE);
+
+    $properties['date'] = DataDefinition::create('any')
+      ->setLabel(t('Computed date'))
+      ->setDescription(t('The computed DateTime object.'))
+      ->setComputed(TRUE)
+      ->setClass('\Drupal\datetime\DateTimeComputed')
+      ->setSetting('date source', 'value');
+
+    return $properties;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function schema(FieldStorageDefinitionInterface $field_definition) {
+    return array(
+      'columns' => array(
+        'value' => array(
+          'description' => 'The date value.',
+          'type' => 'varchar',
+          'length' => 20,
+        ),
+      ),
+      'indexes' => array(
+        'value' => array('value'),
+      ),
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function storageSettingsForm(array &$form, FormStateInterface $form_state, $has_data) {
+    $element = array();
+
+    $element['datetime_type'] = array(
+      '#type' => 'select',
+      '#title' => t('Date type'),
+      '#description' => t('Choose the type of date to create.'),
+      '#default_value' => $this->getSetting('datetime_type'),
+      '#options' => array(
+        static::DATETIME_TYPE_DATETIME => t('Date and time'),
+        static::DATETIME_TYPE_DATE => t('Date only'),
+      ),
+      '#disabled' => $has_data,
+    );
+
+    return $element;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function generateSampleValue(FieldDefinitionInterface $field_definition) {
+    $type = $field_definition->getSetting('datetime_type');
+
+    // Just pick a date in the past year. No guidance is provided by this Field
+    // type.
+    $timestamp = REQUEST_TIME - mt_rand(0, 86400 * 365);
+    if ($type == DateTimeItem::DATETIME_TYPE_DATE) {
+      $values['value'] = gmdate(DATETIME_DATE_STORAGE_FORMAT, $timestamp);
+    }
+    else {
+      $values['value'] = gmdate(DATETIME_DATETIME_STORAGE_FORMAT, $timestamp);
+    }
+    return $values;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function isEmpty() {
+    $value = $this->get('value')->getValue();
+    return $value === NULL || $value === '';
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function onChange($property_name, $notify = TRUE) {
+    // Enforce that the computed date is recalculated.
+    if ($property_name == 'value') {
+      $this->date = NULL;
+    }
+    parent::onChange($property_name, $notify);
+  }
+
+}

web/core/modules/datetime/src/Plugin/Field/FieldWidget/DateTimeDatelistWidget.php

@@ -0,0 +1,149 @@
+<?php
+
+namespace Drupal\datetime\Plugin\Field\FieldWidget;
+
+use Drupal\Core\Field\FieldItemListInterface;
+use Drupal\Core\Form\FormStateInterface;
+
+/**
+ * Plugin implementation of the 'datetime_datelist' widget.
+ *
+ * @FieldWidget(
+ *   id = "datetime_datelist",
+ *   label = @Translation("Select list"),
+ *   field_types = {
+ *     "datetime"
+ *   }
+ * )
+ */
+class DateTimeDatelistWidget extends DateTimeWidgetBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function defaultSettings() {
+    return array(
+      'increment' => '15',
+      'date_order' => 'YMD',
+      'time_type' => '24',
+    ) + parent::defaultSettings();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function formElement(FieldItemListInterface $items, $delta, array $element, array &$form, FormStateInterface $form_state) {
+    $element = parent::formElement($items, $delta, $element, $form, $form_state);
+
+    $date_order = $this->getSetting('date_order');
+
+    if ($this->getFieldSetting('datetime_type') == 'datetime') {
+      $time_type = $this->getSetting('time_type');
+      $increment = $this->getSetting('increment');
+    }
+    else {
+      $time_type = '';
+      $increment = '';
+    }
+
+    // Set up the date part order array.
+    switch ($date_order) {
+      case 'YMD':
+        $date_part_order = array('year', 'month', 'day');
+        break;
+
+      case 'MDY':
+        $date_part_order = array('month', 'day', 'year');
+        break;
+
+      case 'DMY':
+        $date_part_order = array('day', 'month', 'year');
+        break;
+    }
+    switch ($time_type) {
+      case '24':
+        $date_part_order = array_merge($date_part_order, array('hour', 'minute'));
+        break;
+
+      case '12':
+        $date_part_order = array_merge($date_part_order, array('hour', 'minute', 'ampm'));
+        break;
+
+      case 'none':
+        break;
+    }
+
+    $element['value'] = array(
+      '#type' => 'datelist',
+      '#date_increment' => $increment,
+      '#date_part_order' => $date_part_order,
+    ) + $element['value'];
+
+    return $element;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  function settingsForm(array $form, FormStateInterface $form_state) {
+    $element = parent::settingsForm($form, $form_state);
+
+    $element['date_order'] = array(
+      '#type' => 'select',
+      '#title' => t('Date part order'),
+      '#default_value' => $this->getSetting('date_order'),
+      '#options' => array('MDY' => t('Month/Day/Year'), 'DMY' => t('Day/Month/Year'), 'YMD' => t('Year/Month/Day')),
+    );
+
+    if ($this->getFieldSetting('datetime_type') == 'datetime') {
+      $element['time_type'] = array(
+        '#type' => 'select',
+        '#title' => t('Time type'),
+        '#default_value' => $this->getSetting('time_type'),
+        '#options' => array('24' => t('24 hour time'), '12' => t('12 hour time')),
+      );
+
+      $element['increment'] = [
+        '#type' => 'select',
+        '#title' => t('Time increments'),
+        '#default_value' => $this->getSetting('increment'),
+        '#options' => [
+          1 => t('1 minute'),
+          5 => t('5 minute'),
+          10 => t('10 minute'),
+          15 => t('15 minute'),
+          30 => t('30 minute'),
+        ],
+      ];
+    }
+    else {
+      $element['time_type'] = array(
+        '#type' => 'hidden',
+        '#value' => 'none',
+      );
+
+      $element['increment'] = [
+        '#type' => 'hidden',
+        '#value' => $this->getSetting('increment'),
+      ];
+    }
+
+    return $element;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function settingsSummary() {
+    $summary = array();
+
+    $summary[] = t('Date part order: @order', array('@order' => $this->getSetting('date_order')));
+    if ($this->getFieldSetting('datetime_type') == 'datetime') {
+      $summary[] = t('Time type: @time_type', array('@time_type' => $this->getSetting('time_type')));
+      $summary[] = t('Time increments: @increment', array('@increment' => $this->getSetting('increment')));
+    }
+
+    return $summary;
+  }
+
+}

web/core/modules/datetime/src/Plugin/Field/FieldWidget/DateTimeDefaultWidget.php

@@ -0,0 +1,91 @@
+<?php
+
+namespace Drupal\datetime\Plugin\Field\FieldWidget;
+
+use Drupal\Core\Entity\EntityStorageInterface;
+use Drupal\Core\Field\FieldItemListInterface;
+use Drupal\Core\Field\FieldDefinitionInterface;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
+use Drupal\datetime\Plugin\Field\FieldType\DateTimeItem;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * Plugin implementation of the 'datetime_default' widget.
+ *
+ * @FieldWidget(
+ *   id = "datetime_default",
+ *   label = @Translation("Date and time"),
+ *   field_types = {
+ *     "datetime"
+ *   }
+ * )
+ */
+class DateTimeDefaultWidget extends DateTimeWidgetBase implements ContainerFactoryPluginInterface {
+
+  /**
+   * The date format storage.
+   *
+   * @var \Drupal\Core\Entity\EntityStorageInterface
+   */
+  protected $dateStorage;
+
+  /**
+   * {@inheritdoc}
+   */
+  public function __construct($plugin_id, $plugin_definition, FieldDefinitionInterface $field_definition, array $settings, array $third_party_settings, EntityStorageInterface $date_storage) {
+    parent::__construct($plugin_id, $plugin_definition, $field_definition, $settings, $third_party_settings);
+
+    $this->dateStorage = $date_storage;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
+    return new static(
+      $plugin_id,
+      $plugin_definition,
+      $configuration['field_definition'],
+      $configuration['settings'],
+      $configuration['third_party_settings'],
+      $container->get('entity.manager')->getStorage('date_format')
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function formElement(FieldItemListInterface $items, $delta, array $element, array &$form, FormStateInterface $form_state) {
+    $element = parent::formElement($items, $delta, $element, $form, $form_state);
+
+    // Identify the type of date and time elements to use.
+    switch ($this->getFieldSetting('datetime_type')) {
+      case DateTimeItem::DATETIME_TYPE_DATE:
+        $date_type = 'date';
+        $time_type = 'none';
+        $date_format = $this->dateStorage->load('html_date')->getPattern();
+        $time_format = '';
+        break;
+
+      default:
+        $date_type = 'date';
+        $time_type = 'time';
+        $date_format = $this->dateStorage->load('html_date')->getPattern();
+        $time_format = $this->dateStorage->load('html_time')->getPattern();
+        break;
+    }
+
+    $element['value'] += array(
+      '#date_date_format' => $date_format,
+      '#date_date_element' => $date_type,
+      '#date_date_callbacks' => array(),
+      '#date_time_format' => $time_format,
+      '#date_time_element' => $time_type,
+      '#date_time_callbacks' => array(),
+    );
+
+    return $element;
+  }
+
+}

web/core/modules/datetime/src/Plugin/Field/FieldWidget/DateTimeWidgetBase.php

@@ -0,0 +1,89 @@
+<?php
+
+namespace Drupal\datetime\Plugin\Field\FieldWidget;
+
+use Drupal\Core\Datetime\DrupalDateTime;
+use Drupal\Core\Field\FieldItemListInterface;
+use Drupal\Core\Field\WidgetBase;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\datetime\Plugin\Field\FieldType\DateTimeItem;
+
+/**
+ * Base class for the 'datetime_*' widgets.
+ */
+class DateTimeWidgetBase extends WidgetBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function formElement(FieldItemListInterface $items, $delta, array $element, array &$form, FormStateInterface $form_state) {
+    // We are nesting some sub-elements inside the parent, so we need a wrapper.
+    // We also need to add another #title attribute at the top level for ease in
+    // identifying this item in error messages. We do not want to display this
+    // title because the actual title display is handled at a higher level by
+    // the Field module.
+
+    $element['#theme_wrappers'][] = 'datetime_wrapper';
+    $element['#attributes']['class'][] = 'container-inline';
+
+    $element['value'] = array(
+      '#type' => 'datetime',
+      '#default_value' => NULL,
+      '#date_increment' => 1,
+      '#date_timezone' => drupal_get_user_timezone(),
+      '#required' => $element['#required'],
+    );
+
+    if ($this->getFieldSetting('datetime_type') == DateTimeItem::DATETIME_TYPE_DATE) {
+      // A date-only field should have no timezone conversion performed, so
+      // use the same timezone as for storage.
+      $element['value']['#date_timezone'] = DATETIME_STORAGE_TIMEZONE;
+    }
+
+    if ($items[$delta]->date) {
+      $date = $items[$delta]->date;
+      // The date was created and verified during field_load(), so it is safe to
+      // use without further inspection.
+      if ($this->getFieldSetting('datetime_type') == DateTimeItem::DATETIME_TYPE_DATE) {
+        // A date without time will pick up the current time, use the default
+        // time.
+        datetime_date_default_time($date);
+      }
+      $date->setTimezone(new \DateTimeZone($element['value']['#date_timezone']));
+      $element['value']['#default_value'] = $date;
+    }
+
+    return $element;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function massageFormValues(array $values, array $form, FormStateInterface $form_state) {
+    // The widget form element type has transformed the value to a
+    // DrupalDateTime object at this point. We need to convert it back to the
+    // storage timezone and format.
+    foreach ($values as &$item) {
+      if (!empty($item['value']) && $item['value'] instanceof DrupalDateTime) {
+        $date = $item['value'];
+        switch ($this->getFieldSetting('datetime_type')) {
+          case DateTimeItem::DATETIME_TYPE_DATE:
+            // If this is a date-only field, set it to the default time so the
+            // timezone conversion can be reversed.
+            datetime_date_default_time($date);
+            $format = DATETIME_DATE_STORAGE_FORMAT;
+            break;
+
+          default:
+            $format = DATETIME_DATETIME_STORAGE_FORMAT;
+            break;
+        }
+        // Adjust the date for storage.
+        $date->setTimezone(new \DateTimezone(DATETIME_STORAGE_TIMEZONE));
+        $item['value'] = $date->format($format);
+      }
+    }
+    return $values;
+  }
+
+}

web/core/modules/datetime/src/Plugin/views/argument/Date.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace Drupal\datetime\Plugin\views\Argument;
+
+use Drupal\views\Plugin\views\argument\Date as NumericDate;
+
+/**
+ * Abstract argument handler for dates.
+ *
+ * Adds an option to set a default argument based on the current date.
+ *
+ * Definitions terms:
+ * - many to one: If true, the "many to one" helper will be used.
+ * - invalid input: A string to give to the user for obviously invalid input.
+ *                  This is deprecated in favor of argument validators.
+ *
+ * @see \Drupal\views\ManyTonOneHelper
+ *
+ * @ingroup views_argument_handlers
+ *
+ * @ViewsArgument("datetime")
+ */
+class Date extends NumericDate {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getDateField() {
+    // Return the real field, since it is already in string format.
+    return "$this->tableAlias.$this->realField";
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getDateFormat($format) {
+    // Pass in the string-field option.
+    return $this->query->getDateFormat($this->getDateField(), $format, TRUE);
+  }
+
+}

web/core/modules/datetime/src/Plugin/views/argument/DayDate.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Drupal\datetime\Plugin\views\argument;
+
+/**
+ * Argument handler for a day.
+ *
+ * @ViewsArgument("datetime_day")
+ */
+class DayDate extends Date {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected $argFormat = 'd';
+
+}

web/core/modules/datetime/src/Plugin/views/argument/FullDate.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Drupal\datetime\Plugin\views\argument;
+
+/**
+ * Argument handler for a full date (CCYYMMDD).
+ *
+ * @ViewsArgument("datetime_full_date")
+ */
+class FullDate extends Date {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected $argFormat = 'Ymd';
+
+}

web/core/modules/datetime/src/Plugin/views/argument/MonthDate.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Drupal\datetime\Plugin\views\argument;
+
+/**
+ * Argument handler for a month.
+ *
+ * @ViewsArgument("datetime_month")
+ */
+class MonthDate extends Date {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected $argFormat = 'm';
+
+}

web/core/modules/datetime/src/Plugin/views/argument/WeekDate.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Drupal\datetime\Plugin\views\argument;
+
+/**
+ * Argument handler for a week.
+ *
+ * @ViewsArgument("datetime_week")
+ */
+class WeekDate extends Date {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected $argFormat = 'W';
+
+}

web/core/modules/datetime/src/Plugin/views/argument/YearDate.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Drupal\datetime\Plugin\views\argument;
+
+/**
+ * Argument handler for a year.
+ *
+ * @ViewsArgument("datetime_year")
+ */
+class YearDate extends Date {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected $argFormat = 'Y';
+
+}

web/core/modules/datetime/src/Plugin/views/argument/YearMonthDate.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Drupal\datetime\Plugin\views\argument;
+
+/**
+ * Argument handler for a year plus month (CCYYMM).
+ *
+ * @ViewsArgument("datetime_year_month")
+ */
+class YearMonthDate extends Date {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected $argFormat = 'Ym';
+
+}

web/core/modules/datetime/src/Plugin/views/filter/Date.php

@@ -0,0 +1,126 @@
+<?php
+
+namespace Drupal\datetime\Plugin\views\filter;
+
+use Drupal\Core\Datetime\DateFormatterInterface;
+use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
+use Drupal\datetime\Plugin\Field\FieldType\DateTimeItem;
+use Drupal\views\FieldAPIHandlerTrait;
+use Drupal\views\Plugin\views\filter\Date as NumericDate;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\HttpFoundation\RequestStack;
+
+/**
+ * Date/time views filter.
+ *
+ * Even thought dates are stored as strings, the numeric filter is extended
+ * because it provides more sensible operators.
+ *
+ * @ingroup views_filter_handlers
+ *
+ * @ViewsFilter("datetime")
+ */
+class Date extends NumericDate implements ContainerFactoryPluginInterface {
+
+  use FieldAPIHandlerTrait;
+
+  /**
+   * The date formatter service.
+   *
+   * @var \Drupal\Core\Datetime\DateFormatterInterface
+   */
+  protected $dateFormatter;
+
+  /**
+   * Date format for SQL conversion.
+   *
+   * @var string
+   *
+   * @see \Drupal\views\Plugin\views\query\Sql::getDateFormat()
+   */
+  protected $dateFormat = DATETIME_DATETIME_STORAGE_FORMAT;
+
+  /**
+   * The request stack used to determin current time.
+   *
+   * @var \Symfony\Component\HttpFoundation\RequestStack
+   */
+  protected $requestStack;
+
+  /**
+   * Constructs a new Date handler.
+   *
+   * @param array $configuration
+   *   A configuration array containing information about the plugin instance.
+   * @param string $plugin_id
+   *   The plugin ID for the plugin instance.
+   * @param mixed $plugin_definition
+   *   The plugin implementation definition.
+   * @param \Drupal\Core\Datetime\DateFormatterInterface $date_formatter
+   *   The date formatter service.
+   * @param \Symfony\Component\HttpFoundation\RequestStack $request_stack
+   *   The request stack used to determine the current time.
+   */
+  public function __construct(array $configuration, $plugin_id, $plugin_definition, DateFormatterInterface $date_formatter, RequestStack $request_stack) {
+    parent::__construct($configuration, $plugin_id, $plugin_definition);
+    $this->dateFormatter = $date_formatter;
+    $this->requestStack = $request_stack;
+
+    // Date format depends on field storage format.
+    $definition = $this->getFieldStorageDefinition();
+    if ($definition->getSetting('datetime_type') === DateTimeItem::DATETIME_TYPE_DATE) {
+      $this->dateFormat = DATETIME_DATE_STORAGE_FORMAT;
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
+    return new static(
+      $configuration,
+      $plugin_id,
+      $plugin_definition,
+      $container->get('date.formatter'),
+      $container->get('request_stack')
+    );
+  }
+
+  /**
+   * Override parent method, which deals with dates as integers.
+   */
+  protected function opBetween($field) {
+    $origin = ($this->value['type'] == 'offset') ? $this->requestStack->getCurrentRequest()->server->get('REQUEST_TIME') : 0;
+    $a = intval(strtotime($this->value['min'], $origin));
+    $b = intval(strtotime($this->value['max'], $origin));
+
+    // Formatting will vary on date storage.
+
+
+    // Convert to ISO format and format for query. UTC timezone is used since
+    // dates are stored in UTC.
+    $a = $this->query->getDateFormat("'" . $this->dateFormatter->format($a, 'custom', DATETIME_DATETIME_STORAGE_FORMAT, DATETIME_STORAGE_TIMEZONE) . "'", $this->dateFormat, TRUE);
+    $b = $this->query->getDateFormat("'" . $this->dateFormatter->format($b, 'custom', DATETIME_DATETIME_STORAGE_FORMAT, DATETIME_STORAGE_TIMEZONE) . "'", $this->dateFormat, TRUE);
+
+    // This is safe because we are manually scrubbing the values.
+    $operator = strtoupper($this->operator);
+    $field = $this->query->getDateFormat($field, $this->dateFormat, TRUE);
+    $this->query->addWhereExpression($this->options['group'], "$field $operator $a AND $b");
+  }
+
+  /**
+   * Override parent method, which deals with dates as integers.
+   */
+  protected function opSimple($field) {
+    $origin = (!empty($this->value['type']) && $this->value['type'] == 'offset') ? $this->requestStack->getCurrentRequest()->server->get('REQUEST_TIME') : 0;
+    $value = intval(strtotime($this->value['value'], $origin));
+
+    // Convert to ISO. UTC is used since dates are stored in UTC.
+    $value = $this->query->getDateFormat("'" . $this->dateFormatter->format($value, 'custom', DATETIME_DATETIME_STORAGE_FORMAT, DATETIME_STORAGE_TIMEZONE) . "'", $this->dateFormat, TRUE);
+
+    // This is safe because we are manually scrubbing the value.
+    $field = $this->query->getDateFormat($field, $this->dateFormat, TRUE);
+    $this->query->addWhereExpression($this->options['group'], "$field $this->operator $value");
+  }
+
+}

web/core/modules/datetime/src/Plugin/views/sort/Date.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Drupal\datetime\Plugin\views\sort;
+
+use Drupal\views\Plugin\views\sort\Date as NumericDate;
+
+/**
+ * Basic sort handler for datetime fields.
+ *
+ * This handler enables granularity, which is the ability to make dates
+ * equivalent based upon nearness.
+ *
+ * @ViewsSort("datetime")
+ */
+class Date extends NumericDate {
+
+  /**
+   * Override to account for dates stored as strings.
+   */
+  public function getDateField() {
+    // Return the real field, since it is already in string format.
+    return "$this->tableAlias.$this->realField";
+  }
+
+  /**
+   * {@inheritdoc}
+   *
+   * Overridden in order to pass in the string date flag.
+   */
+  public function getDateFormat($format) {
+    return $this->query->getDateFormat($this->getDateField(), $format, TRUE);
+  }
+
+}