strawberryfield.module

<?php

/**
 * @file
 * Contains strawberryfield.module.
 */

use Drupal\Core\Entity\ContentEntityInterface;
use Drupal\Core\Entity\EntityPublishedInterface;
use Drupal\Core\Render\Markup;
use Drupal\strawberryfield\Event\StrawberryfieldCrudEvent;
use Drupal\strawberryfield\StrawberryfieldEventType;
use Drupal\Core\Field\BaseFieldDefinition;
use Drupal\Core\Entity\EntityTypeInterface;
use Drupal\Core\StreamWrapper\StreamWrapperInterface;
use Drupal\Core\Field\FieldStorageDefinitionInterface;
use Drupal\strawberryfield\Field\StrawberryFieldFileComputedItemList;
use Drupal\strawberryfield\Field\StrawberryFieldEntityComputedItemList;
use Drupal\strawberryfield\StrawberryfieldRenderCallbacks;
use Drupal\Core\Access\AccessResult;
use Drupal\Core\Field\FieldDefinitionInterface;
use Drupal\Core\Session\AccountInterface;
use Drupal\Core\Field\FieldItemListInterface;
use Drupal\Core\Entity\Display\EntityViewDisplayInterface;
use Drupal\Core\Entity\EntityInterface;
use Drupal\node\NodeInterface;


/**
 * Implements hook_ENTITY_TYPE_presave().
 */
function strawberryfield_node_presave(ContentEntityInterface $entity) {
  if ($sbf_fields = \Drupal::service('strawberryfield.utility')->bearsStrawberryfield($entity)) {
    $config = \Drupal::config('strawberryfield.general');
    $bench = FALSE;
    // When benchmark is enabled a simple but effective report will be found in
    // the reports/logs.
    if ($config->get('benchmark')) {
      $bench = TRUE;
      $start_time = microtime(true);
    }
    // Introducing our newest development, the processing time stats!
    // Starting on PHP 7.3 we should use hrtime for docker and VMS.
    // https://www.php.net/manual/en/function.microtime.php
    // @TODO make bench simply an Event Method! That way we can measure every
    // event by calling it and for new ones. Etc.
    $event_type = StrawberryfieldEventType::PRESAVE;
    $event = new StrawberryfieldCrudEvent($event_type, $entity, $sbf_fields);
    \Drupal::service('event_dispatcher')->dispatch($event, $event_type);

    if ($bench) {
      $end_time = microtime(TRUE);
      // Removed bsuc.
      $time = round($end_time - $start_time, 4);
      $max_memory = memory_get_peak_usage(TRUE);
      $events = '';
      foreach ($event->getProcessedBy() as $event_info) {
        $success = $event_info['success'] ? 'Successful' : 'Failure';
        $events .= '<li>' . $event_info['class'] . ' => ' . $success . '</li>';
      }
      \Drupal::logger('strawberryfield')->notice(
        'ADO with UUID @uuid spent @time seconds on all presave event subscriber processing and max memory usage was @maxmem. <br> Event Subscribers that could run were the following: <br><ul>@events</ul>',
        [
          '@uuid' => $entity->uuid(),
          '@time' => $time,
          '@maxmem' => \Drupal::service('strawberryfield.utility')->formatBytes($max_memory, 2),
          '@events' => Markup::create($events),
        ]
      );
    }
  }
}

/**
 * Implements hook_ENTITY_TYPE_update().
 */
function strawberryfield_node_update(ContentEntityInterface $entity) {
  if ($sbf_fields = \Drupal::service('strawberryfield.utility')->bearsStrawberryfield($entity)) {
    $event_type = StrawberryfieldEventType::SAVE;
    $event = new StrawberryfieldCrudEvent($event_type, $entity, $sbf_fields);
    \Drupal::service('event_dispatcher')->dispatch($event, $event_type);
  }
}

/**
 * Implements hook_ENTITY_TYPE_insert().
 */
function strawberryfield_node_insert(ContentEntityInterface $entity) {
  // @TODO move this to an event subscriber.
  strawberryfield_invalidate_fieldefinition_caches($entity);

  if ($sbf_fields = \Drupal::service('strawberryfield.utility')->bearsStrawberryfield($entity)) {
    $event_type = StrawberryfieldEventType::INSERT;
    $event = new StrawberryfieldCrudEvent($event_type, $entity, $sbf_fields);
    \Drupal::service('event_dispatcher')->dispatch($event, $event_type);
    // @TODO use updated $event object to debug things if an event failed.
    // via $event->getProcessedBy();
  }
}

/**
 * Implements hook_ENTITY_TYPE_revision_create().
 */
function strawberryfield_node_revision_create(ContentEntityInterface $new_revision, ContentEntityInterface $entity, $keep_untranslatable_fields) {
  if ($sbf_fields = \Drupal::service('strawberryfield.utility')->bearsStrawberryfield($entity)) {
    $event_type = StrawberryfieldEventType::NEW_REVISION;
    $event = new StrawberryfieldCrudEvent($event_type, $new_revision, $sbf_fields);
    \Drupal::service('event_dispatcher')->dispatch($event, $event_type);
  }
}

/**
 * Implements hook_ENTITY_TYPE_delete().
 */
function strawberryfield_node_delete(ContentEntityInterface $entity) {
  if ($sbf_fields = \Drupal::service('strawberryfield.utility')->bearsStrawberryfield($entity)) {
    $event_type = StrawberryfieldEventType::DELETE;
    $event = new StrawberryfieldCrudEvent($event_type, $entity, $sbf_fields);
    \Drupal::service('event_dispatcher')->dispatch($event, $event_type);
  }
}

/**
 * Implements hook_ENTITY_TYPE_revision_delete().
 */
function strawberryfield_node_revision_delete(ContentEntityInterface $entity) {

  if ($sbf_fields = \Drupal::service('strawberryfield.utility')->bearsStrawberryfield($entity)) {
    $event_type = StrawberryfieldEventType::DELETE;
    $event = new StrawberryfieldCrudEvent($event_type, $entity, $sbf_fields);
    \Drupal::service('event_dispatcher')->dispatch($event, $event_type);
  }
  // @TODO move this to an event subscriber.
  strawberryfield_invalidate_fieldefinition_caches($entity);
}

/**
 * Invalidate the cache for strawberryfields field type defintions.
 *
 * @param \Drupal\Core\Entity\ContentEntityInterface $entity
 *   The entity to invalidate cache.
 */
function strawberryfield_invalidate_fieldefinition_caches(ContentEntityInterface $entity) {
  // @TODO do the same for StrawberryfieldKeyNameProvider Plugins
  if ($entity instanceof EntityPublishedInterface && $entity->isPublished() && $entity->isDefaultRevision()) {
    $needscleaning = FALSE;
    $strawberry_field_class = $class = \Drupal::service('plugin.manager.field.field_type')->getPluginClass('strawberryfield_field');
    foreach ($entity->getFieldDefinitions() as $field) {
      $class = $field->getItemDefinition()->getClass();
      $is_ripe = ($class === $strawberry_field_class) || is_subclass_of($class, $strawberry_field_class);
      if ($is_ripe) {
        $needscleaning = TRUE;
      }
    }

    if ($needscleaning) {
      \Drupal::service('plugin.manager.field.field_type')->clearCachedDefinitions();
    }
  }
}

/**
 * Implements hook_entity_base_field_info().
 */
function strawberryfield_entity_base_field_info(EntityTypeInterface $entity_type) {
  if ($entity_type->id() != 'node') {
    return [];
  }
  $scheme_options = \Drupal::service('stream_wrapper_manager')->getNames(StreamWrapperInterface::WRITE_VISIBLE);
  if (isset($scheme_options['private'])) {
    $schema = 'private';
  }
  elseif (isset($scheme_options['public'])) {
    $schema = 'public';
  }
  else {
    $schema = 'public';
  }

  $fields = [];
  // Add a field that serves as a drop box for any entities that bear a SBF.
  // @see https://www.drupal.org/project/drupal/issues/2346347
  // (still WIP as June 2020)
  // know why we can't use \Drupal\Core\Field\BaseFieldDefinition
  // @TODO If we try to make this Bundle specific?
  // @Update 20202: https://www.previousnext.com.au/blog/how-create-and-expose-computed-properties-rest-api-drupal-8
  // Issue with that approach is we need to have a hook update for every
  // bundle Which makes adding new bundles and attaching automagically super
  // complex.
  // @TODO future work on exposing other JSON properties as other REAL field types
  // Dynamically can be achieved by creating a new Class extending
  // BaseFieldDefinition.
  // That manages without hickups the 'Bundle' option
  // \Drupal\Core\Field\BaseFieldDefinition::setTargetBundle
  $fields['field_file_drop'] = BaseFieldDefinition::create('entity_reference')
    ->setName('field_file_drop')
    ->setLabel(t('Drop Files'))
    ->setComputed(TRUE)
    ->setRevisionable(FALSE)
    ->setTranslatable(FALSE)
    ->setCardinality(FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED)
    ->setReadOnly(FALSE)
    ->setTargetEntityTypeId($entity_type->id())
    ->setSettings(
      [
        'target_type' => 'file',
        'file_directory' => 'sbf_tmp',
        'uri_scheme' => $schema,
      ]
    )
    ->setClass(StrawberryFieldFileComputedItemList::class)
    ->setDisplayConfigurable('view', FALSE)
    ->setDisplayConfigurable('form', FALSE);

  // A computed field to store customly detected Node references from a SBF.
  $fields['field_sbf_nodetonode'] = BaseFieldDefinition::create('entity_reference')
    ->setName('field_sbf_nodetonode')
    ->setLabel('Related ADOs')
    ->setSetting('target_type', 'node')
    ->setTargetEntityTypeId('node')
    ->setDescription(t('Computed Node to Node relationships'))
    ->setComputed(TRUE)
    ->setCardinality(FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED)
    ->setRevisionable(FALSE)
    ->setReadOnly(TRUE)
    ->setTranslatable(FALSE)
    ->setClass(StrawberryFieldEntityComputedItemList::class);

  return $fields;
}

/**
 * Implements hook_entity_bundle_field_info().
 */
function strawberryfield_entity_bundle_field_info(EntityTypeInterface $entity_type, $bundle, array $base_field_definitions) {
  // This is a good workaround for ISSUE-86
  // Will basically attach the base field as a bundled one and by doing so
  // Allow our bundle based permissions to be evaluated.
  if (($entity_type->id() == 'node') && isset($base_field_definitions['field_file_drop'])) {
    if (\Drupal::service('strawberryfield.utility')->bundleHasStrawberryfield($bundle)) {
      // Add the target bundle to the field_file_drop base field
      // only if it carries a Strawberryfield
      // In practice this will allow Bundle specific create access permissions
      // to work and force anything not Strawberryfield to either have the node
      // access override or simply not work.
      $base_field_definitions['field_file_drop']->setTargetBundle($bundle);
      return [
        'field_file_drop' => $base_field_definitions['field_file_drop'],
      ];
    }
  }
  // Ask around. Do we need to expose this virtual creature the same way given
  // that is its read only?
  if (($entity_type->id() == 'node') && isset($base_field_definitions['field_sbf_nodetonode'])) {
    if (\Drupal::service('strawberryfield.utility')
      ->bundleHasStrawberryfield($bundle)) {

      // Add the target bundle to the field_file_drop base field
      // only if it carries a Strawberryfield
      // In practice this will allow Bundle specific create access permissions
      // to work and force anything not Strawberryfield to either have the node
      // access override or simply not work.
      $base_field_definitions['field_sbf_nodetonode']->setTargetBundle($bundle);
      return [
        'field_sbf_nodetonode' => $base_field_definitions['field_sbf_nodetonode'],
      ];
    }
  }
}

/**
 * Implements hook_entity_field_access().
 */
function strawberryfield_entity_field_access($operation, FieldDefinitionInterface $field_definition, AccountInterface $account, FieldItemListInterface $items = NULL) {
  if ($field_definition->getName() == 'field_file_drop') {
    return AccessResult::allowedIfHasPermission($account, 'upload to Digital Object file dropbox field');
  }
  return AccessResult::neutral();
}

/**
 * Implements hook_file_mimetype_mapping_alter().
 */
function strawberryfield_file_mimetype_mapping_alter(&$mapping) {
  // Add relevant Repository Mimetypes missing from D8.
  $mapping['mimetypes']['json_mimetype'] = 'application/json';
  $mapping['extensions']['json'] = 'json_mimetype';
  $mapping['mimetypes']['jsonld_mimetype'] = 'application/ld+json';
  $mapping['extensions']['jsonld'] = 'jsonld_mimetype';
  $mapping['mimetypes']['jpeg2000_mimetype'] = 'image/jp2';
  $mapping['extensions']['jp2'] = 'jpeg2000_mimetype';
  $mapping['mimetypes']['fits_image_mimetype'] = 'image/fits';
  // @see https://en.wikipedia.org/wiki/FITS
  $mapping['extensions']['fits'] = 'fits_image_mimetype';
  $mapping['extensions']['fit'] = 'fits_image_mimetype';
  $mapping['extensions']['fts'] = 'fits_image_mimetype';
  $mapping['extensions']['stl'] = 'stl_model_mimetype';
  // @see https://www.iana.org/assignments/media-types/media-types.xhtml
  $mapping['mimetypes']['stl_model_mimetype'] = 'model/stl';
  // @ WACZ WIP.
  $mapping['mimetypes']['wacz_mimetype'] = 'application/vnd.datapackage+zip';
  $mapping['extensions']['wacz'] = 'wacz_mimetype';

}

/**
 * Implements hook_s3fs_url_settings_alter().
 */
function strawberryfield_s3fs_url_settings_alter(array &$url_settings, $s3_file_path) {
  // @TODO This is a soft dependency. Means if we have no s3fs module all good.
  // Idea here is to allow in the future
  // signed urls to be generated given a certain condition
  // Or to force AWS S3 metatags to control maybe object lifecycle.
  // if ($s3_file_path == 'myfile.jpg') {
  // $url_settings['presigned_url'] = TRUE;
  // $url_settings['timeout'] = 10;
  // }
  // An example of adding a custom GET argument to all S3 URLs that
  // records the name of the currently logged in user.
  // $account = Drupal::currentUser();
  // $url_settings['custom_GET_args']['x-user'] = $account->getAccountName();
}

/**
 * Implements hook_cron().
 */
function strawberryfield_cron() {
  // @TODO: Drush calls to CRON do not release the background process? Wait
  // For ever for the exec() to return, even if calling with nohup.
  // @Giancarlobi.. not sure why. So this will only run if normal CRON/web based
  // Is invoked but never with `drush cron`
  if (PHP_SAPI != 'cli') {
    \Drupal::getContainer()->get('strawberryfield.hydroponics')->run();
  }
}

/**
 * Implements hook_entity_view_alter().
 */
function strawberryfield_entity_view_alter(array &$build, EntityInterface $entity, EntityViewDisplayInterface $display) {
  $excerpt_component = $display->getComponent('search_api_excerpt');
  if ($excerpt_component !== NULL && $entity instanceof NodeInterface && $entity->view ?? NULL) {
    if (\Drupal::request()->getMethod() == 'GET' ) {
      // if mixing SQL/Search API (e.g the result row is rendered using a View that is not Search API
      // But the listing is obviously an Search API view i can't trust that getQuery() will
      // be driven by searchAPI, so might not have an index.
      // @TODO. Review every call to ->getIndex() everywhere. Bc method is specific to that plugin (no interface)
      if ($entity->view instanceof \Drupal\views\ViewExecutable) {
        if ($entity->view->getQuery() instanceof \Drupal\search_api\Plugin\views\query\SearchApiQuery) {
          // Check if the current index has lazy_excerpt enabled...
          if ($processor = ($entity->view->getQuery()->getIndex()->getProcessors(
          )['sbf_highlight'] ?? NULL)
          ) {
            if ($processor->getConfiguration()['lazy_excerpt'] ?? NULL) {
              $cid = 'entity:' . $entity->getEntityTypeId() . '/' . $entity->id()
                . ':'
                . $entity->language()->getId();
              $build['search_api_excerpt'] = [
                '#lazy_builder'       => [
                  'strawberryfield.lazy_builders:renderExcerpt',
                  [$cid, 'node:'.$entity->id()]
                ],
                '#create_placeholder' => TRUE,
              ];
            }
          }
        }
      }
    }
  }
}

/**
* Implements hook_element_info_alter().
 */
function strawberryfield_element_info_alter(array &$info): void {
  array_unshift($info['view']['#pre_render'], 'Drupal\strawberryfield\StrawberryfieldRenderCallbacks::preRender');
}