View source
<?php
namespace Drupal\fullcalendar\Plugin\views\style;
use DateTime;
use DateTimeZone;
use Drupal\Component\Plugin\PluginManagerInterface;
use Drupal\Component\Utility\NestedArray;
use Drupal\Core\Datetime\DateFormatter;
use Drupal\Core\Extension\ModuleHandlerInterface;
use Drupal\Core\Form\FormStateInterface;
use Drupal\Core\Messenger\MessengerInterface;
use Drupal\datetime\Plugin\Field\FieldType\DateTimeItemInterface;
use Drupal\fullcalendar\Plugin\FullcalendarBase;
use Drupal\fullcalendar\Plugin\FullcalendarPluginCollection;
use Drupal\views\Plugin\views\style\StylePluginBase;
use Symfony\Component\DependencyInjection\ContainerInterface;
class FullCalendar extends StylePluginBase {
protected $usesFields = TRUE;
protected $usesGrouping = FALSE;
protected $moduleHandler;
protected $fieldManager;
protected $pluginBag;
protected $dateFormatter;
protected $messenger;
public function evenEmpty() {
return TRUE;
}
public function getPlugins() {
return $this->pluginBag;
}
public function __construct(array $configuration, $plugin_id, $plugin_definition, PluginManagerInterface $fullcalendar_manager, ModuleHandlerInterface $module_handler, $field_manager, DateFormatter $date_formatter, MessengerInterface $messenger) {
parent::__construct($configuration, $plugin_id, $plugin_definition);
$this->pluginBag = new FullcalendarPluginCollection($fullcalendar_manager, $this);
$this->moduleHandler = $module_handler;
$this->fieldManager = $field_manager;
$this->dateFormatter = $date_formatter;
$this->messenger = $messenger;
}
public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
return new static($configuration, $plugin_id, $plugin_definition, $container
->get('plugin.manager.fullcalendar'), $container
->get('module_handler'), $container
->get('entity_field.manager'), $container
->get('date.formatter'), $container
->get('messenger'));
}
protected function defineOptions() {
$options = parent::defineOptions();
foreach ($this
->getPlugins() as $plugin) {
if ($plugin instanceof FullcalendarBase) {
$options += $plugin
->defineOptions();
}
}
return $options;
}
public function buildOptionsForm(&$form, FormStateInterface $form_state) {
parent::buildOptionsForm($form, $form_state);
foreach ($this
->getPlugins() as $plugin) {
if ($plugin instanceof FullcalendarBase) {
$plugin
->buildOptionsForm($form, $form_state);
}
}
}
public function validateOptionsForm(&$form, FormStateInterface $form_state) {
parent::validateOptionsForm($form, $form_state);
if ($form_state
->getValue('style_options')) {
$this
->castNestedValues($form_state
->getValue('style_options'), $form);
}
}
protected function castNestedValues(array &$values, array $form, $current_key = NULL, array $parents = []) {
foreach ($values as $key => &$value) {
if (empty($current_key)) {
array_pop($parents);
}
$parents[] = $key;
if (is_array($value)) {
$this
->castNestedValues($value, $form, $key, $parents);
}
else {
$form_value = NestedArray::getValue($form, $parents);
if (isset($form_value['#data_type'])) {
settype($value, $form_value['#data_type']);
}
array_pop($parents);
}
}
}
public function submitOptionsForm(&$form, FormStateInterface $form_state) {
parent::submitOptionsForm($form, $form_state);
foreach ($this
->getPlugins() as $plugin) {
if ($plugin instanceof FullcalendarBase) {
$plugin
->submitOptionsForm($form, $form_state);
}
}
}
public function parseFields($include_gcal = TRUE) {
$this->view
->initHandlers();
$labels = $this->displayHandler
->getFieldLabels();
$date_fields = [];
foreach ($this->view->field as $id => $field) {
if (fullcalendar_field_is_date($field, $include_gcal)) {
$date_fields[$id] = $labels[$id];
}
}
return $date_fields;
}
public function validate() {
if ($this->displayHandler->display['display_plugin'] != 'default' && !$this
->parseFields()) {
$this->messenger
->addWarning($this
->t('Display "@display" requires at least one date field.', [
'@display' => $this->displayHandler->display['display_title'],
]), 'error');
}
return parent::validate();
}
public function render() {
$this->options['#attached'] = $this
->prepareAttached();
return [
'#theme' => $this
->themeFunctions(),
'#view' => $this->view,
'#options' => $this->options,
];
}
protected function prepareAttached() {
$attached['library'][] = 'fullcalendar/drupal.fullcalendar';
foreach ($this
->getPlugins() as $plugin_id => $plugin) {
$definition = $plugin
->getPluginDefinition();
foreach ([
'css',
'js',
] as $type) {
if ($definition[$type]) {
$attached['library'][] = $definition['provider'] . '/drupal.' . $plugin_id . '.' . $type;
}
}
}
if ($this->displayHandler
->getOption('use_ajax')) {
$attached['library'][] = 'fullcalendar/drupal.fullcalendar.ajax';
}
$settings = $this
->prepareSettings();
$attached['drupalSettings']['fullcalendar'] = [
'.js-view-dom-id-' . $this->view->dom_id => $settings,
];
if (!empty($settings['fullcalendar']['modalWindow'])) {
$attached['library'][] = 'core/drupal.ajax';
$attached['library'][] = 'core/drupal.dialog';
$attached['library'][] = 'core/drupal.dialog.ajax';
}
return $attached;
}
protected function prepareSettings() {
$settings =& drupal_static(__METHOD__, []);
if (empty($settings)) {
$weights = [];
$delta = 0;
foreach ($this
->getPlugins() as $plugin_id => $plugin) {
$definition = $plugin
->getPluginDefinition();
$plugin
->process($settings);
if (isset($definition['weight']) && !isset($weights[$definition['weight']])) {
$weights[$definition['weight']] = $plugin_id;
}
else {
while (isset($weights[$delta])) {
$delta++;
}
$weights[$delta] = $plugin_id;
}
}
ksort($weights);
$settings['weights'] = array_values($weights);
$settings['fullcalendar']['disableResizing'] = TRUE;
$settings['fullcalendar']['showNonCurrentDates'] = FALSE;
$settings['fullcalendar']['fixedWeekCount'] = FALSE;
if (empty($settings['fullcalendar']['editable'])) {
$settings['fullcalendar']['editable'] = TRUE;
}
else {
$settings['fullcalendar']['editable'] = FALSE;
}
$settings['fullcalendar']['locale'] = \Drupal::languageManager()
->getCurrentLanguage()
->getId();
}
$settings['fullcalendar']['_events'] = $this
->prepareEvents();
return $settings;
}
protected function prepareEvents() {
$events = [];
foreach ($this->view->result as $delta => $row) {
$entity = $row->_entity;
$fields = [];
$date_fields = [];
$event = [];
foreach ($this->view->field as $field_name => $field) {
$fields[$field_name] = $this
->getField($delta, $field_name);
if (fullcalendar_field_is_date($field)) {
$field_storage_definitions = $this->fieldManager
->getFieldStorageDefinitions($field->definition['entity_type']);
$field_definition = $field_storage_definitions[$field->definition['field_name']];
$date_fields[$field_name] = [
'value' => $field
->getItems($row),
'field_alias' => $field->field_alias,
'field_name' => $field_definition
->getName(),
'field_info' => $field_definition,
'timezone_override' => $field->options['settings']['timezone_override'],
];
}
}
if (!empty($this->options['fields']['date'])) {
$date_fields = array_intersect_key($date_fields, $this->options['fields']['date_field']);
}
if (empty($date_fields)) {
return $events;
}
foreach ($date_fields as $field) {
if (empty($field['value'])) {
continue;
}
$field_definition = $field['field_info'];
$date_range = $this
->getExposedDates($field['field_name']);
if ($field_definition
->getType() == 'date_recur') {
$field_items = $row->_entity->{$field['field_name']};
$isRecurring = FALSE;
foreach ($field_items as $index => $item) {
$occurrenceHandler = $item
->getOccurrenceHandler();
if ($occurrenceHandler
->isRecurring()) {
$occurrences = $occurrenceHandler
->getOccurrencesForDisplay($date_range['min'], $date_range['max']);
foreach ($occurrences as $occurrence) {
$start = $occurrence['value'];
$end = $occurrence['end_value'];
$event = $this
->prepareEvent($entity, $field, $index, $start, $end);
}
$isRecurring = TRUE;
}
}
if ($isRecurring === TRUE) {
continue;
}
}
foreach ($field['value'] as $index => $item) {
if (empty($item['raw']->value)) {
continue;
}
$event_start = new DateTime();
$event_start
->setTimestamp(strtotime($item['raw']->value));
if (!empty($field['timezone_override'])) {
$event_start
->setTimeZone(new DateTimeZone($field['timezone_override']));
}
$event_end = new DateTime();
$event_end
->setTimestamp($event_start
->getTimestamp() + 3600);
if (!empty($item['raw']->end_value)) {
$event_end
->setTimestamp(strtotime($item['raw']->end_value));
if (!empty($field['timezone_override'])) {
$event_end
->setTimeZone(new DateTimeZone($field['timezone_override']));
}
}
$event_start
->setTimestamp($event_start
->getTimestamp() + $event_start
->getOffset());
$event_end
->setTimestamp($event_end
->getTimestamp() + $event_end
->getOffset());
$event = $this
->prepareEvent($entity, $field, $index, $event_start, $event_end);
}
}
if (!empty($event)) {
$events[$delta] = $event;
}
}
return $events;
}
private function prepareEvent($entity, $field, $delta, $event_start, $event_end) {
$classes = $this->moduleHandler
->invokeAll('fullcalendar_classes', [
$entity,
]);
$this->moduleHandler
->alter('fullcalendar_classes', $classes, $entity);
$classes = array_map([
'\\Drupal\\Component\\Utility\\Html',
'getClass',
], $classes);
$class = count($classes) ? implode(' ', array_unique($classes)) : '';
$palette = $this->moduleHandler
->invokeAll('fullcalendar_palette', [
$entity,
]);
$this->moduleHandler
->alter('fullcalendar_palette', $palette, $entity);
$request_time = \Drupal::time()
->getRequestTime();
$current_time = new DateTime();
$current_time
->setTimestamp($request_time);
$date_range = $this
->getExposedDates($field['field_name']);
$all_day = FALSE;
if ($event_start <= $date_range['min'] && $event_end >= $date_range['max']) {
$all_day = TRUE;
}
if ($all_day && $event_start < $current_time || !$all_day && $event_end < $current_time) {
$time_class = 'fc-event-past';
}
elseif ($event_start > $current_time) {
$time_class = 'fc-event-future';
}
else {
$time_class = 'fc-event-now';
}
if (!empty($settings['fullcalendar']['editable'])) {
$editable = $entity
->access('update', NULL, TRUE)
->isAllowed();
}
else {
$editable = FALSE;
}
return [
'allDay' => (int) $all_day,
'start' => $this->dateFormatter
->format($event_start
->getTimestamp(), 'custom', DateTimeItemInterface::DATETIME_STORAGE_FORMAT),
'end' => $this->dateFormatter
->format($event_end
->getTimestamp(), 'custom', DateTimeItemInterface::DATETIME_STORAGE_FORMAT),
'editable' => !empty($editable) ? 'true' : 'false',
'field' => $field['field_name'],
'index' => $delta,
'eid' => $entity
->id(),
'entity_type' => $entity
->getEntityTypeId(),
'className' => $class . ' ' . $time_class,
'title' => strip_tags(htmlspecialchars_decode($entity
->label(), ENT_QUOTES)),
'url' => $entity
->toUrl('canonical', [
'language' => \Drupal::languageManager()
->getCurrentLanguage(),
])
->toString(),
'backgroundColor' => !empty($palette['backgroundColor']) ? $palette['backgroundColor'] : '',
'borderColor' => !empty($palette['borderColor']) ? $palette['borderColor'] : '',
'textColor' => !empty($palette['textColor']) ? $palette['textColor'] : '',
];
}
public function getExposedDates($field_name) {
$dates =& drupal_static(__METHOD__, []);
if (empty($dates[$field_name])) {
$entity_type = $this->view
->getBaseEntityType();
$entity_type_id = $entity_type
->id();
$settings = $this->view->style_plugin->options;
$field_manager = \Drupal::getContainer()
->get('entity_field.manager');
$field_storages = $field_manager
->getFieldStorageDefinitions($entity_type_id);
$field_storage = $field_storages[$field_name];
$field_value = $field_storage
->getName() . '_value';
$exposed_input = $this->view
->getExposedInput();
$dateMin = new DateTime();
$dateMax = new DateTime();
if (isset($exposed_input[$field_value])) {
$dateMin
->setTimestamp(strtotime($exposed_input[$field_value]['min']));
$dateMax
->setTimestamp(strtotime($exposed_input[$field_value]['max']));
}
elseif (!empty($settings['date']['month']) && !empty($settings['date']['year'])) {
$ts = mktime(0, 0, 0, $settings['date']['month'] + 1, 1, $settings['date']['year']);
$dateMin
->setTimestamp($ts);
$dateMax
->setTimestamp($ts);
$dateMin
->modify('first day of this month');
$dateMax
->modify('first day of next month');
}
else {
$dateMin
->modify('first day of this month');
$dateMax
->modify('first day of next month');
}
$dates[$field_name] = [
'min' => $dateMin,
'max' => $dateMax,
];
}
return $dates[$field_name];
}
}