stanford_media.module

<?php

/**
 * @file
 * stanford_media.module
 */

use Drupal\Core\Access\AccessResult;
use Drupal\Core\Entity\Display\EntityViewDisplayInterface;
use Drupal\Core\Entity\EntityInterface;
use Drupal\Core\Entity\EntityTypeInterface;
use Drupal\Core\Form\FormStateInterface;
use Drupal\Core\Session\AccountInterface;
use Drupal\editor\Entity\Editor;
use Drupal\file\FileInterface;
use Drupal\media\Entity\MediaType;
use Drupal\media\MediaInterface;
use Drupal\stanford_media\Form\MediaLibraryEmbeddableForm;
use Drupal\stanford_media\Form\MediaLibraryFileUploadForm;
use Drupal\stanford_media\Form\MediaLibraryGoogleFormForm;

/**
 * Implements hook_ENTITY_TYPE_delete().
 */
function stanford_media_media_delete(MediaInterface $media) {
  \Drupal::service('stanford_media')->deleteMediaFiles($media);
}

/**
 * Implements hook_entity_bundle_field_info_alter().
 */
function stanford_media_entity_bundle_field_info_alter(&$fields, EntityTypeInterface $entity_type, $bundle) {
  if ($entity_type->id() == 'media') {
    /** @var \Drupal\media\MediaTypeInterface $media_type */
    $media_type = MediaType::load($bundle);
    if (!$media_type) {
      return;
    }

    $source = $media_type->getSource();

    // If the media type is using the embeddable plugin, add a constraint on the
    // unstructured code field.
    if ($source->getPluginId() == 'embeddable') {
      $unstructured_field = $source->getConfiguration()['unstructured_field_name'] ?? '';
      if (isset($fields[$unstructured_field])) {
        $fields[$unstructured_field]->addConstraint('embeddable');
      }
    }
  }
}

/**
 * Implements hook_ENTITY_TYPE_presave().
 */
function stanford_media_media_presave(MediaInterface $entity) {
  $source = MediaType::load($entity->bundle())->getSource();
  // When the media entity has raw embed code, modify it using the validation
  // plugin before the entity is saved.
  if (
    $source->getPluginId() == 'embeddable' &&
    !\Drupal::currentUser()->hasPermission('bypass embed field validation')
  ) {
    /** @var \Drupal\stanford_media\Plugin\media\Source\Embeddable $source */
    if ($source->hasUnstructured($entity)) {
      $unstructured_field = $source->getConfiguration()['unstructured_field_name'] ?? '';
      $code = $source->getSourceFieldValue($entity);
      $code = $source->prepareEmbedCode($code);
      $entity->set($unstructured_field, $code);
    }
  }
}

/**
 * Implements hook_field_widget_form_alter().
 */
function stanford_media_field_widget_form_alter(&$element, FormStateInterface $form_state, $context) {
  /** @var \Drupal\Core\Field\FieldItemListInterface $items */
  $items = $context['items'];
  if ($items->getFieldDefinition()->getType() == 'image') {
    $element['#process'][] = [
      '\Drupal\stanford_media\StanfordMedia',
      'imageWidgetProcess',
    ];
  }
}

/**
 * Implements hook_field_widget_WIDGET_TYPE_form_alter().
 */
function stanford_media_field_widget_text_textarea_form_alter(&$element, FormStateInterface $form_state, $context) {
  // Adds the library outside of ckeditor iframe.
  $element['#attached']['library'][] = 'stanford_media/admin';
}

/**
 * Implements hook_ckeditor_css_alter().
 */
function stanford_media_ckeditor_css_alter(array &$css, Editor $editor) {
  /** @var \Drupal\Core\Extension\ModuleExtensionList $extensions */
  $extensions = \Drupal::service('extension.list.module');
  // Add styles inside the ckeditor iframe.
  $css[] = $extensions->getPath('stanford_media') . '/dist/css/stanford_media.admin.css';
  $css[] = $extensions->getPath('stanford_media') . '/dist/css/stanford_media.css';
}

/**
 * Implements hook_theme_registry_alter().
 */
function stanford_media_theme_registry_alter(&$theme_registry) {
  // Register the path to the template files.
  $path = \Drupal::service('extension.list.module')->getPath('stanford_media') . '/templates';
  $theme_registry['dropzonejs']['path'] = $path;
}

/**
 * Implements hook_ENTITY_TYPE_view_alter().
 */
function stanford_media_media_view_alter(array &$build, EntityInterface $entity, EntityViewDisplayInterface $display) {
  if (empty($build['#embed'])) {
    return;
  }

  foreach (_stanford_media_get_dialog_plugins($entity) as $plugin) {
    $plugin->embedAlter($build, $entity);
  }
  $build['#attached']['library'][] = 'stanford_media/display';
}

/**
 * Get a list of all plugins applicable for the entity.
 *
 * @param \Drupal\Core\Entity\EntityInterface $entity
 *   The media entity to check for plugins.
 *
 * @return \Drupal\stanford_media\Plugin\MediaEmbedDialogInterface[]
 *   Array of applicable plugins.
 *
 * @throws \Drupal\Component\Plugin\Exception\PluginException
 */
function _stanford_media_get_dialog_plugins(EntityInterface $entity) {
  $plugins = [];
  /** @var \Drupal\stanford_media\Plugin\MediaEmbedDialogManager $dialog_manager */
  $dialog_manager = \Drupal::service('plugin.manager.media_embed_dialog_manager');
  foreach (array_keys($dialog_manager->getDefinitions()) as $plugin_id) {
    /** @var \Drupal\stanford_media\Plugin\MediaEmbedDialogInterface $plugin */
    $plugin = $dialog_manager->createInstance($plugin_id, ['entity' => $entity]);

    if ($plugin->isApplicable()) {
      $plugins[$plugin_id] = $plugin;
    }
  }
  return $plugins;
}

/**
 * Implements hook_media_source_info_alter().
 */
function stanford_media_media_source_info_alter(array &$sources) {
  $sources['audio_file']['forms']['media_library_add'] = MediaLibraryFileUploadForm::class;
  $sources['file']['forms']['media_library_add'] = MediaLibraryFileUploadForm::class;
  $sources['image']['forms']['media_library_add'] = MediaLibraryFileUploadForm::class;
  $sources['video_file']['forms']['media_library_add'] = MediaLibraryFileUploadForm::class;
  $sources['google_form']['forms']['media_library_add'] = MediaLibraryGoogleFormForm::class;
  $sources['embeddable']['forms']['media_library_add'] = MediaLibraryEmbeddableForm::class;
}

/**
 * Implements hook_preprocess_HOOK().
 */
function stanford_media_preprocess_dropzonejs(&$variables) {
  // Adds additional things to the template for the dropzone js widget.
  $variables['allowed_files'] = str_replace(' ', ', ', $variables['element']['#extensions']);
}

/**
 * Implements hook_preprocess_HOOK().
 */
function stanford_media_preprocess_media(&$variables) {

  /** @var \Drupal\media\MediaInterface $media */
  $media = $variables['media'];
  if ($media->getSource()->getPluginId() != 'file') {
    return;
  }
  $media_type = \Drupal::entityTypeManager()
    ->getStorage('media_type')
    ->load($media->bundle());
  $source_field = $media->getSource()
    ->getSourceFieldDefinition($media_type)
    ->getName();

  if (empty($variables['content'][$source_field][0]['#description'])) {
    $variables['content'][$source_field][0]['#description'] = $variables['name'];
  }
}

/**
 * Implements hook_preprocess_HOOK().
 */
function stanford_media_preprocess_filter_caption(&$variables) {
  if (!isset($variables['classes'])) {
    $variables['classes'] = '';
  }
  $variables['classes'] = trim($variables['classes'] . ' caption');
}

/**
 * Implements hook_ENTITY_TYPE_prepare_form().
 */
function stanford_media_media_prepare_form(MediaInterface $media, $operation, FormStateInterface $form_state) {
  /** @var \Drupal\entity_usage\EntityUsageInterface $entity_usage_service */
  $entity_usage_service = \Drupal::service('entity_usage.usage');
  $sources = $entity_usage_service->listSources($media);
  $count = 0;
  foreach ($sources as $source) {
    $count += count($source);
  }
  // Display a message to the user to alert them than editing will affect
  // multiple pieces of content.
  if ($count) {
    $message = \Drupal::translation()->formatPlural(
      $count,
      'Changing this media item will affect %count piece of content.',
      'Changing this media item will affect %count pieces of content.',
      ['%count' => $count]
    );
    \Drupal::messenger()->addWarning($message);
  }

}

/**
 * Implements hook_entity_access().
 *
 * Restrict access to media entities that are used as field default values.
 */
function stanford_media_entity_access(EntityInterface $entity, $operation, AccountInterface $account) {

  // Only lock down the media entities since they are the default field values
  // that we care about.
  if (
    $entity->getEntityTypeId() != 'media' ||
    !in_array($operation, ['update', 'delete'])
  ) {
    return AccessResult::neutral();
  }

  $configs = \Drupal::configFactory()->listAll('field.field.');
  foreach ($configs as $config_name) {
    $config = \Drupal::config($config_name);

    // Check for the fields we are interested by checking their type and handler
    // settings.
    if (
      $config->get('field_type') == 'entity_reference' &&
      $config->get('settings.handler') == 'default:media' &&
      !empty($config->get('default_value'))
    ) {
      $default_value = $config->get('default_value');

      // The field default value matches the current media entity so we want to
      // forbid editing/deleting if the user doesn't have the proper permission.
      if (!empty($default_value[0]['target_uuid']) && $entity->uuid() == $default_value[0]['target_uuid']) {
        return AccessResult::forbiddenIf(!$account->hasPermission('edit field default media'), 'The entity is set as a default field value.');
      }
    }
  }

  return AccessResult::neutral();
}

/**
 * Implements hook_ENTITY_TYPE_insert().
 */
function stanford_media_file_insert(FileInterface $file) {
  $extension = pathinfo($file->getFileUri(), PATHINFO_EXTENSION);
  $file_path = \Drupal::service('file_system')->realpath($file->getFileUri());
  if (
    !in_array($extension, ['jpg', 'jpeg', 'png']) ||
    !file_exists($file_path) ||
    !class_exists('Imagick')
  ) {
    return;
  }
  try {
    $image = new Imagick($file_path);
    switch ($image->getImageOrientation()) {
      case imagick::ORIENTATION_BOTTOMRIGHT:
        // Rotate 180 degrees.
        $image->rotateimage("#000", 180);
        break;

      case imagick::ORIENTATION_RIGHTTOP:
        // Rotate 90 degrees CW.
        $image->rotateimage("#000", 90);
        break;

      case imagick::ORIENTATION_LEFTBOTTOM:
        // Rotate 90 degrees CCW.
        $image->rotateimage("#000", -90);
        break;
    }

    // Now that it's rotated, set the orientation, before stripping all other
    // tags.
    $image->setImageOrientation(imagick::ORIENTATION_TOPLEFT);

    // 1. Extract the ICC profile
    // 2. Strip EXIF data and image profile
    // 3. Add the ICC profile back
    $profiles = $image->getImageProfiles('icc');
    $image->stripImage();
    if (isset($profiles['icc'])) {
      $image->profileImage('icc', $profiles['icc']);
    }

    $image->writeImage($file_path);
  }
  catch (\Exception $e) {
    \Drupal::logger('stanford_media')
      ->error('Unable to strip metadata & fix orientation from image: %path', ['%path' => $file_path]);
  }
}