sync.module

<?php

/**
 * @file
 * Contains sync.module.
 */

use Drupal\Core\Entity\EntityChangedInterface;
use Drupal\Core\Routing\RouteMatchInterface;
use Drupal\Core\Entity\EntityInterface;
use Drupal\Core\Entity\EntityFormInterface;
use Drupal\Core\Entity\FieldableEntityInterface;
use Drupal\Core\Form\FormStateInterface;
use Drupal\Core\Url;
use Drupal\sync\Plugin\Field\FieldWidget\ReadonlyFieldWidget;
use Drupal\views\Plugin\views\query\QueryPluginBase;
use Drupal\views\ViewExecutable;

/**
 * Implements hook_help().
 */
function sync_help($route_name, RouteMatchInterface $route_match) {
  switch ($route_name) {
    // Main module help for the sync module.
    case 'help.page.sync':
      $output = '';
      $output .= '<h3>' . t('About') . '</h3>';
      $output .= '<p>' . t('Data migration suite.') . '</p>';
      return $output;

    default:
  }
}

/**
 * Implements hook_cron().
 */
function sync_cron() {
  // Sites driving sync from a dedicated runner (drush sync:cron) turn this off
  // so that core cron does not build a competing run.
  if (\Drupal::config('sync.settings')->get('cron_build') === FALSE) {
    return;
  }
  $manager = \Drupal::service('plugin.manager.sync_resource');
  foreach ($manager->getForCron() as $instance) {
    /** @var \Drupal\sync\Plugin\SyncResourceInterface $instance */
    $instance->build(['%sync_as_cron' => TRUE]);
  }
}

/**
 * Implements hook_entity_delete().
 */
function sync_entity_delete(EntityInterface $entity) {
  \Drupal::service('sync.storage')->deleteByProperties([
    'entity_id' => $entity->id(),
    'entity_type' => $entity->getEntityTypeId(),
  ]);
}

/**
 * Implements hook_entity_presave().
 */
function sync_entity_presave(EntityInterface $entity) {
  if (isset($entity->__sync_changed) && $entity instanceof EntityChangedInterface) {
    $entity->setChangedTime(\Drupal::time()->getRequestTime());
  }
}

/**
 * Implements hook_entity_insert().
 */
function sync_entity_insert(EntityInterface $entity) {
  sync_entity_update($entity);
}

/**
 * Implements hook_entity_update().
 */
function sync_entity_update(EntityInterface $entity) {
  if (isset($entity->__sync_id)) {
    \Drupal::service('sync.storage')->saveEntity($entity);
  }
}

/**
 * Implements hook_entity_operation().
 *
 * Offers a Lock/Unlock operation on any entity sync tracks. Locking is how an
 * entity that has been edited locally is protected from being overwritten by
 * the next run.
 */
function sync_entity_operation(EntityInterface $entity) {
  // Locking is opt-in. Both of these are far cheaper than the storage lookup,
  // which would otherwise run for every row of every entity listing.
  if (!\Drupal::config('sync.settings')->get('lock_enabled')) {
    return [];
  }
  if (!\Drupal::currentUser()->hasPermission('sync lock')) {
    return [];
  }
  if ($entity->isNew()) {
    return [];
  }
  $records = \Drupal::service('sync.storage')->loadByEntity($entity);
  if (!$records) {
    return [];
  }
  $locked = FALSE;
  foreach ($records as $record) {
    if (!empty($record->locked)) {
      $locked = TRUE;
      break;
    }
  }
  return [
    'sync_lock' => [
      'title' => $locked ? t('Unlock from sync') : t('Lock from sync'),
      'weight' => 50,
      'url' => Url::fromRoute('sync.entity_lock', [
        'sync_entity_type' => $entity->getEntityTypeId(),
        'sync_entity_id' => $entity->id(),
      ], [
        'query' => \Drupal::destination()->getAsArray(),
      ]),
    ],
  ];
}

/**
 * Implements hook_field_widget_info_alter().
 */
function sync_field_widget_info_alter(array &$info) {
  // Let the readonly field widget be useable on all field types.
  $formatters = \Drupal::service('plugin.manager.field.formatter')->getDefinitions();
  $field_types = [];
  foreach ($formatters as $formatter) {
    $field_types = array_merge($field_types, $formatter['field_types']);
  }
  $info['sync_readonly']['field_types'] = array_unique($field_types);
}

/**
 * Implements hook_form_alter().
 */
function sync_form_alter(&$form, FormStateInterface $form_state, $form_id) {
  // Check that this is an entity form.
  $form_object = $form_state->getFormObject();
  if ($form_object instanceof EntityFormInterface) {
    $entity = $form_object->getEntity();
    // Set access to readonly widget items based on their view access.
    $storage = $form_state->getStorage();
    if ($entity instanceof FieldableEntityInterface && isset($storage['form_display'])) {
      /** @var \Drupal\Core\Entity\Display\EntityFormDisplayInterface $form_display */
      $form_display = $storage['form_display'];
    }
    else {
      return;
    }
    foreach ($form_display->getComponents() as $name => $options) {
      $widget = $form_display->getRenderer($name);
      if ($widget instanceof ReadonlyFieldWidget && $entity instanceof FieldableEntityInterface) {
        $items = $entity->get($name);
        $items->filterEmptyItems();
        $form[$name]['#access'] = $items->access('view');
      }
    }
  }

  if ($form_id === 'system_cron_settings') {
    $cron_url = Url::fromRoute('sync.cron', ['key' => \Drupal::state()->get('system.cron_key')], ['absolute' => TRUE])->toString();

    $form['cron_url'] = [
      'drupal' => $form['cron_url'],
      'sync' => [
        '#markup' => '<p>' . t('For long-running tasks that will immediately return a 204 response, go to <a href=":cron" class="system-cron-settings__link">@cron</a>', [':cron' => $cron_url, '@cron' => $cron_url]) . '</p>',
      ],
    ];
  }

}

/**
 * Implements hook_queue_info_alter().
 */
function sync_queue_info_alter(&$definitions) {
  $config = \Drupal::config('sync.settings');
  // Sites driving sync from a dedicated runner (drush sync:cron) set this to
  // FALSE so core cron does not claim items out from under it. Omitting the
  // 'cron' key entirely makes Cron::processQueues() skip the queue.
  $cron_queue = $config->get('cron_queue');
  $cron_queue = $cron_queue === NULL ? TRUE : (bool) $cron_queue;
  // Bounds the per-queue processing budget so the inline-cron fallback in
  // SyncSubscriber (used when exec() is disabled or drush isn't available)
  // can't park an FPM worker for too long.
  $cron_queue_time = (int) ($config->get('cron_queue_time') ?: 30);
  foreach (\Drupal::service('plugin.manager.sync_resource')->getDefinitions() as $key => $definition) {
    $info = [
      'id' => 'sync_' . $key,
      'title' => $definition['label'],
      'class' => 'Drupal\sync\Plugin\QueueWorker\Sync',
      'provider' => 'sync',
    ];
    if ($cron_queue) {
      $info['cron'] = ['time' => $cron_queue_time];
    }
    $definitions['sync_' . $key] = $info;
  }
}

/**
 * Implements hook_views_query_alter().
 */
function sync_views_query_alter(ViewExecutable $view, QueryPluginBase $query) {
  if ($view->id() == 'sync_watchdog' && !empty($view->args[1])) {
    // Show only logs since start of most recent run.
    $query->addWhere('', 'watchdog.timestamp', $view->args[1], '>');
  }
}

/**
* Implements hook_mail().
*/
function sync_mail($key, &$message, $params) {
  switch ($key) {
    case 'end_fail':
      $message['headers']['Content-Type'] = 'text/html; charset=UTF-8; format=flowed';
      $message['from'] = \Drupal::config('system.site')->get('mail');
      $message['subject'] = $params['%subject'];
      $message['body'][] = $params['%message'];
      break;
  }
 }