thunder.install

<?php

/**
 * @file
 * Install, update and uninstall functions for the thunder installation profile.
 */

use Drupal\Component\Utility\NestedArray;
use Drupal\views\Entity\View;
use Drupal\user\Entity\Role;
use Drupal\user\Entity\User;
use Drupal\Core\Entity\EntityStorageException;
use Drupal\metatag\Entity\MetatagDefaults;
use Drupal\field\Entity\FieldConfig;
use Drupal\paragraphs\Entity\Paragraph;

/**
 * Update hook dependencies.
 *
 * 1. Dependency on Thunder Updater module.
 * 2. Ensure that Thunder updates come last so entity schema updates and more
 *    fundamental updates occur first.
 *
 * @return mixed
 *   Returns list of update hook dependencies.
 */
function thunder_update_dependencies() {

  $installThunderUpdaterHook = ['thunder' => 8103];

  $dependencies['thunder'] = [
    8006 => $installThunderUpdaterHook,
  ];

  // Ensure that all thunder hook_update_N functions are called after all other
  // update hooks.
  $list = [];
  $return = [];
  $updates = update_get_update_list();

  // List of thunder modules with hook_update_N() functions.
  $thunder_module_list = [
    'thunder',
    'thunder_article',
    'thunder_liveblog',
    'thunder_media',
    'thunder_paragraphs',
    'thunder_taxonomy',
  ];

  foreach ($updates as $module => $info) {
    if (in_array($module, $thunder_module_list, TRUE)) {
      // Build a list of thunder modules with updates to run.
      $return[$module] = [];
    }
    else {
      // Build the list of all the update hooks for thunder updates to depend
      // on.
      $pending = array_keys($info['pending']);
      $list[$module] = array_pop($pending);
    }
  }

  // Add the dependencies to the thunder modules with updates to run.
  foreach ($return as $module => &$info) {
    $info[$updates[$module]['start']] = $list;
  }

  return NestedArray::mergeDeepArray([$return, $dependencies], TRUE);
}

/**
 * Install the thunder installation profile.
 */
function thunder_install() {

  drupal_get_messages();

  // Enable the admin theme.
  \Drupal::configFactory()
    ->getEditable('node.settings')
    ->set('use_admin_theme', TRUE)
    ->save(TRUE);

  // Set frontend theme.
  \Drupal::configFactory()
    ->getEditable('system.theme')
    ->set('default', 'thunder_base')
    ->save(TRUE);

  $profilePath = drupal_get_path('profile', 'thunder');
  \Drupal::configFactory()
    ->getEditable('thunder_base.settings')
    ->set('logo.use_default', FALSE)
    ->set('logo.path', $profilePath . '/themes/thunder_base/images/Thunder-white_400x90.png')
    ->save(TRUE);

  // Assign user 1 the "administrator" role.
  $user = User::load(1);
  $user->roles[] = 'administrator';
  $user->save();

  // Set default pages.
  \Drupal::configFactory()->getEditable('system.site')
    ->set('page.front', '/node')
    ->save(TRUE);

  // Configure user registration.
  \Drupal::configFactory()
    ->getEditable('user.settings')
    ->set('register', 'visitors_admin_approval')
    ->save(TRUE);

  \Drupal::service('thunder_updater.update_checklist')->markAllUpdates();

}

/**
 * Adds metatag configuration.
 */
function thunder_update_8001() {

  \Drupal::service('module_installer')->install([
    'config_update',
    'metatag_open_graph',
    'metatag_twitter_cards',
  ]);

  $configs = [
    'metatag_defaults' => ['node__article'],
    'image_style' => ['twitter', 'facebook'],
  ];

  foreach ($configs as $entity => $ids) {
    foreach ($ids as $id) {
      try {
        \Drupal::service('config_update.config_update')->import($entity, $id);
      }
      catch (EntityStorageException $e) {
      }
    }
  }

  $meta = MetatagDefaults::load('global');
  $tags = $meta->get('tags');
  if (empty($tags['og_site_name'])) {
    $tags['og_site_name'] = '[site:name]';
  }
  if (empty($tags['twitter_cards_type'])) {
    $tags['twitter_cards_type'] = 'summary';
  }
  $meta->set('tags', $tags);
  $meta->save();
}

/**
 * Enable thunder_fia.
 */
function thunder_update_8002() {

  if (\Drupal::moduleHandler()->moduleExists('fb_instant_articles')) {
    $modules = \Drupal::configFactory()
      ->getEditable('core.extension')
      ->get('module');

    $modules['thunder_fia'] = 1;

    \Drupal::configFactory()
      ->getEditable('core.extension')
      ->set('module', $modules)
      ->save();
  }
}

/**
 * Fix metatag config.
 */
function thunder_update_8003() {

  $sandbox = [];
  module_load_include('install', 'metatag');

  metatag_update_8102($sandbox);
  metatag_update_8103();

  // Reset the default field values.
  $entity_manager = \Drupal::service('entity.manager');

  // Get all of the field storage entities of type metatag.
  $field_storage_configs = $entity_manager
    ->getStorage('field_storage_config')
    ->loadByProperties(['type' => 'metatag']);

  foreach ($field_storage_configs as $field_storage) {
    $field_name = $field_storage->getName();

    // Get the individual fields (field instances) associated with bundles.
    /** @var \Drupal\field\Entity\FieldConfig[] $fields */
    $fields = $entity_manager->getStorage('field_config')
      ->loadByProperties(['field_name' => $field_name]);

    foreach ($fields as $field) {

      $field->setDefaultValue(serialize([]));
      $field->save();
    }
  }
}

/**
 * Require instagram and twitter url field.
 */
function thunder_update_8004() {

  $config = FieldConfig::load('media.instagram.field_url');
  if ($config) {
    $config->setRequired(TRUE)->save();
  }

  $config = FieldConfig::load('media.twitter.field_url');
  if ($config) {
    $config->setRequired(TRUE)->save();
  }
}

/**
 * Add author filter to content view.
 */
function thunder_update_8005() {

  /** @var \Drupal\views\Entity\View $view */
  $view = View::load('content');

  if (empty($view->getDisplay('default')['display_options']['filters']['uid'])) {

    $uid['uid'] = [
      'id' => 'uid',
      'table' => 'node_field_data',
      'field' => 'uid',
      'relationship' => 'none',
      'group_type' => 'group',
      'admin_label' => '',
      'operator' => 'in',
      'value' =>
        [],
      'group' => 1,
      'exposed' => TRUE,
      'expose' =>
        [
          'operator_id' => 'uid_op',
          'label' => 'Authored by',
          'description' => '',
          'use_operator' => FALSE,
          'operator' => 'uid_op',
          'identifier' => 'uid',
          'required' => FALSE,
          'remember' => FALSE,
          'multiple' => FALSE,
          'remember_roles' =>
            [
              'authenticated' => 'authenticated',
              'anonymous' => '0',
              'editor' => '0',
              'seo' => '0',
              'administrator' => '0',
            ],
          'reduce' => FALSE,
        ],
      'is_grouped' => FALSE,
      'group_info' =>
        [
          'label' => '',
          'description' => '',
          'identifier' => '',
          'optional' => TRUE,
          'widget' => 'select',
          'multiple' => FALSE,
          'remember' => FALSE,
          'default_group' => 'All',
          'default_group_multiple' =>
            [],
          'group_items' =>
            [],
        ],
      'entity_type' => 'node',
      'entity_field' => 'uid',
      'plugin_id' => 'user_name',
    ];

    $newArray = array_slice($view->getDisplay('default')['display_options']['filters'], 0, 4, TRUE) +
      $uid +
      array_slice($view->getDisplay('default')['display_options']['filters'], 4, NULL, TRUE);

    $view->getDisplay('default')['display_options']['filters'] = $newArray;
    $view->save();
  }

}

/**
 * Adds instagram preview mode.
 */
function thunder_update_8006() {

  \Drupal::service('module_installer')->install([
    'config_update',
  ]);

  /** @var \Drupal\thunder_updater\UpdateLogger $updateLogger */
  $updateLogger = Drupal::service('thunder_updater.logger');

  $configs = [
    'entity_view_display' => [
      'paragraph.instagram.preview',
      'media.instagram.thumbnail',
    ],
  ];

  /** @var Drupal\config_update\ConfigRevertInterface $configReverter */
  $configReverter = \Drupal::service('config_update.config_update');

  // Ensure that required view mode exists.
  if (empty($configReverter->getFromActive('entity_view_mode', 'media.thumbnail'))) {
    $configReverter->import('entity_view_mode', 'media.thumbnail');
  }

  // Import listed configurations.
  foreach ($configs as $entity => $ids) {
    foreach ($ids as $id) {
      try {
        $configReverter->import($entity, $id);
      }
      catch (\Exception $e) {
        $updateLogger->warning(t('Unable to import @entity.@id config.', [
          '@id' => $id,
          '@entity' => $entity,
        ]));
      }
    }
  }

  return $updateLogger->output();
}

/**
 * Installs the responsive_preview module.
 */
function thunder_update_8101() {

  \Drupal::service('module_installer')->install([
    'responsive_preview',
  ]);
}

/**
 * Installs the access_unpublished module.
 */
function thunder_update_8102() {

  \Drupal::service('module_installer')->install([
    'access_unpublished',
  ]);
}

/**
 * Installs the thunder_updater module.
 */
function thunder_update_8103() {

  // We let exception bubble in this case, since it's not possible to continue
  // with execution of update hooks without "thunder_updater" service.
  \Drupal::service('module_installer')->install(['thunder_updater']);

  /** @var \Drupal\thunder_updater\Updater $thunderUpdater */
  $thunderUpdater = \Drupal::service('thunder_updater');

  $thunderUpdater->checklist()->markAllUpdates(FALSE);

  // Now Thunder updater is enabled, we can start marking checkboxes.
  $thunderUpdater->installModules([
    'v1_1__responsive_preview' => 'responsive_preview',
    'v1_1__access_unpublished' => 'access_unpublished',
  ]);

  return $thunderUpdater->logger()->output();
}

/**
 * Installs the metatag_facebook module.
 */
function thunder_update_8104() {

  /** @var \Drupal\thunder_updater\Updater $thunderUpdater */
  $thunderUpdater = \Drupal::service('thunder_updater');

  $thunderUpdater->installModules([
    'v1_1__metatag_facebook' => 'metatag_facebook',
  ]);

  return $thunderUpdater->logger()->output();
}

/**
 * Installs the config_update module.
 */
function thunder_update_8105() {

  /** @var \Drupal\thunder_updater\Updater $thunderUpdater */
  $thunderUpdater = \Drupal::service('thunder_updater');

  $thunderUpdater->installModules([
    'v1_1__config_update' => 'config_update',
  ]);

  return $thunderUpdater->logger()->output();
}

/**
 * Installs the diff module.
 */
function thunder_update_8106() {

  /** @var \Drupal\thunder_updater\Updater $thunderUpdater */
  $thunderUpdater = \Drupal::service('thunder_updater');

  $thunderUpdater->installModules([
    'v1_1__diff' => 'diff',
  ]);

  return $thunderUpdater->logger()->output();
}

/**
 * Installs the thunder_riddle module.
 *
 * This replaces the riddle paragraphs by a new one, using media_entity as
 * a base. After that you are able to select riddles out of the entity browser.
 */
function thunder_update_8107() {

  /** @var \Drupal\thunder_updater\Updater $thunderUpdater */
  $thunderUpdater = \Drupal::service('thunder_updater');
  $updateLogger = $thunderUpdater->logger();

  $entityTypeManager = \Drupal::entityTypeManager();
  $paragraphType = $entityTypeManager->getStorage('paragraphs_type')
    ->load('paragraphs_riddle_marketplace');

  $successfulUpdate = TRUE;
  if (!empty($paragraphType)) {
    if (\Drupal::service('module_installer')->install(['thunder_riddle'])) {

      // Import Riddles.
      \Drupal::service('media_riddle_marketplace')->createMediaEntities();

      /** @var \Drupal\paragraphs\Entity\Paragraph[] $paragraphs */
      $paragraphs = $entityTypeManager->getStorage('paragraph')
        ->loadByProperties([
          'type' => 'paragraphs_riddle_marketplace',
        ]);

      foreach ($paragraphs as $oldParagraph) {

        $fieldName = $oldParagraph->get('parent_field_name')->get(0)->getString();

        $host = $oldParagraph->getParentEntity();
        if ($host) {

          foreach ($host->get($fieldName)->getValue() as $delta => $field) {
            if ($field['target_id'] == $oldParagraph->id()) {

              /* @var \Drupal\media_entity\Entity\Media */
              $media = $entityTypeManager->getStorage('media')
                ->loadByProperties([
                  'bundle' => 'riddle',
                  'field_riddle_id' => pathinfo(parse_url($oldParagraph->get('field_link')->uri)['path'])['filename'],
                ]);
              $media = current($media);

              // Create new Riddle paragraph for media.
              try {
                $paragraph = Paragraph::create([
                  'type' => 'riddle',
                  'field_riddle' => $media->id(),
                ]);
                $paragraph->save();
              }
              catch (EntityStorageException $storageException) {
                $updateLogger->warning(t(
                  'Could not create paragraph for @riddle in @name.',
                  [
                    '@riddle' => $media->label(),
                    '@name' => $host->label(),
                  ]
                ));
                $successfulUpdate = FALSE;

                // Since paragraph is not created - skip further execution.
                continue;
              }

              // Add new paragraph to parent entity.
              $host->get($fieldName)->set($delta, [
                'target_id' => $paragraph->id(),
                'target_revision_id' => $paragraph->getRevisionId(),
              ]);

              try {
                $host->save();
                $updateLogger->info(t('Converted @riddle in @name.', ['@riddle' => $media->label(), '@name' => $host->label()]));

                // After successful saving -> remove old paragraph.
                try {
                  $oldParagraph->delete();
                }
                catch (EntityStorageException $storageException) {
                  $updateLogger->warning(t('Could not delete @riddle in @name.', ['@riddle' => $media->label(), '@name' => $host->label()]));
                  $successfulUpdate = FALSE;
                }
              }
              catch (EntityStorageException $storageException) {
                $updateLogger->warning(t('Could not convert @riddle in @name.', ['@riddle' => $media->label(), '@name' => $host->label()]));
                $successfulUpdate = FALSE;
              }
            }
          }
        }
      }

      if ($successfulUpdate) {
        try {
          $fieldConfigs = $entityTypeManager->getStorage('field_config')
            ->loadByProperties(['field_type' => 'entity_reference_revisions']);

          foreach ($fieldConfigs as $field) {
            $settings = $field->getSetting('handler_settings');

            unset($settings['target_bundles']['paragraphs_riddle_marketplace']);
            unset($settings['target_bundles_drag_drop']['paragraphs_riddle_marketplace']);

            $field->setSetting('handler_settings', $settings);
            $field->save();
          }

          $paragraphType->delete();
          $updateLogger->info(t('Old riddle paragraph type is successfully removed.'));
        }
        catch (\Exception $e) {
          $successfulUpdate = FALSE;

          $updateLogger->warning(t('Removing of old riddle paragraph type has failed.'));
        }
      }
    }
    else {
      $successfulUpdate = FALSE;

      $updateLogger->warning(t('Riddle module is not available.'));
    }
  }

  if ($successfulUpdate) {
    $thunderUpdater->checklist()->markUpdatesSuccessful(['v1_1__thunder_riddle']);
  }
  else {
    $thunderUpdater->checklist()->markUpdatesFailed(['v1_1__thunder_riddle']);
  }

  return $updateLogger->output();
}

/**
 * Adjust access permissions related to "access_unpublished" module.
 */
function thunder_update_8108() {
  /** @var \Drupal\thunder_updater\UpdateLogger $updateLogger */
  $updateLogger = \Drupal::service('thunder_updater.logger');

  // Granting permissions only for "anonymous" and "authenticated" user roles.
  $roles = Role::loadMultiple(['anonymous', 'authenticated']);

  foreach ($roles as $role) {
    if ($role->hasPermission('access content')) {
      try {
        $role->grantPermission('access_unpublished node article');
        $role->save();

        $updateLogger->info(t('Permission for accessing unpublished node with generated token Url is granted for @user_role user role.', ['@user_role' => $role->id()]));
      }
      catch (EntityStorageException $storageException) {
        $updateLogger->warning(t('Unable to change permissions for @user_role user role.', ['@user_role' => $role->id()]));
      }
    }
    else {
      $updateLogger->info(t('Skipping @user_role user role, because of non-sufficient permissions.', ['@user_role' => $role->id()]));
    }
  }

  // Output logged result of update hook execution.
  return $updateLogger->output();
}

/**
 * Change paragraphs add mode to use the modal.
 */
function thunder_update_8109() {

  /** @var \Drupal\thunder_updater\Updater $thunderUpdater */
  $thunderUpdater = \Drupal::service('thunder_updater');
  $updateLogger = $thunderUpdater->logger();

  // List of configurations that should be checked for existence.
  $expectedConfig['content']['field_paragraphs']['settings']['add_mode'] = 'dropdown';

  // New configuration that should be applied.
  $newConfig['content']['field_paragraphs']['settings']['add_mode'] = 'modal';

  $successfulUpdate = TRUE;

  foreach (['node.article', 'taxonomy_term.channel', 'taxonomy_term.tags'] as $item) {
    if ($thunderUpdater->updateConfig('core.entity_form_display.' . $item . '.default', $newConfig, $expectedConfig)) {
      $updateLogger->info(t('Adjusted form display for @item default', ['@item' => $item]));
    }
    else {
      $successfulUpdate = FALSE;

      $updateLogger->warning(t('Unable to adjust form display for @item default', ['@item' => $item]));
    }
  }

  if ($successfulUpdate) {
    $thunderUpdater->checklist()->markUpdatesSuccessful(['v1_1__paragraphs_modal']);
  }
  else {
    $updateLogger->warning(t('Unable to adjust paragraphs add mode.'));
    $thunderUpdater->checklist()->markUpdatesFailed(['v1_1__paragraphs_modal']);
  }

  return $updateLogger->output();
}

/**
 * Adjust access permissions related to "responsive_preview" module.
 */
function thunder_update_8110() {
  /** @var \Drupal\thunder_updater\UpdateLogger $updateLogger */
  $updateLogger = \Drupal::service('thunder_updater.logger');

  // Granting permissions only for "editor" and "seo" user roles.
  $roles = Role::loadMultiple(['editor', 'seo']);

  foreach ($roles as $role) {
    if ($role->hasPermission('access content')) {
      try {
        $role->grantPermission('access responsive preview');
        $role->save();

        $updateLogger->info(t('Permission for accessing responsive preview is granted for @user_role user role.', ['@user_role' => $role->id()]));
      }
      catch (EntityStorageException $storageException) {
        $updateLogger->warning(t('Unable to change permissions for @user_role user role.', ['@user_role' => $role->id()]));
      }
    }
    else {
      $updateLogger->info(t('Skipping @user_role user role, because of non-sufficient permissions.', ['@user_role' => $role->id()]));
    }
  }

  // Output logged result of update hook execution.
  return $updateLogger->output();
}

/**
 * Adjust permissions related to "video_embed_field" module.
 */
function thunder_update_8111() {
  /** @var \Drupal\thunder_updater\UpdateLogger $updateLogger */
  $updateLogger = \Drupal::service('thunder_updater.logger');

  // Granting permissions only for "editor" and "seo" user roles.
  $roles = Role::loadMultiple(['editor', 'seo']);

  foreach ($roles as $role) {
    try {
      $role->grantPermission('never autoplay videos');
      $role->save();

      $updateLogger->info(t('Permission for never autoplay videos is granted for @user_role user role.', ['@user_role' => $role->id()]));
    }
    catch (EntityStorageException $storageException) {
      $updateLogger->warning(t('Unable to change permissions for @user_role user role.', ['@user_role' => $role->id()]));
    }

  }

  // Output logged result of update hook execution.
  return $updateLogger->output();
}

/**
 * Installs new Thunder Admin theme.
 */
function thunder_update_8112() {

  /** @var \Drupal\thunder_updater\Updater $thunderUpdater */
  $thunderUpdater = \Drupal::service('thunder_updater');
  $updateLogger = $thunderUpdater->logger();

  $successfulUpdate = TRUE;

  // Order is important, because of dependencies.
  $importConfigs = [
    'core.entity_form_mode.media.inline',
    'image.style.paragraph_preview_thumbnail',
    'core.entity_view_mode.media.paragraph_preview',
    'field.storage.media.field_author',
    'field.storage.media.field_content',
    'field.field.media.twitter.field_author',
    'field.field.media.twitter.field_content',
    'field.field.media.instagram.field_author',
    'field.field.media.instagram.field_content',
    'core.entity_view_display.media.gallery.paragraph_preview',
    'core.entity_view_display.media.image.paragraph_preview',
    'core.entity_view_display.media.twitter.paragraph_preview',
    'core.entity_view_display.media.instagram.paragraph_preview',
    'core.entity_view_display.media.video.paragraph_preview',
    'core.entity_view_display.paragraph.link.preview',
    'core.entity_view_display.paragraph.twitter.preview',
    'core.entity_form_display.media.image.inline',
    'core.entity_form_display.media.video.inline',
  ];

  if (!$thunderUpdater->importConfigs($importConfigs)) {
    $successfulUpdate = FALSE;
  }

  $updateList = [
    ['thunder_media', 'thunder_media__thunder_update_8112'],
    ['thunder_paragraphs', 'thunder_paragraphs__thunder_update_8112'],
    ['thunder_article', 'thunder_article__thunder_update_8112'],
    ['thunder', 'thunder__thunder_update_8112'],
  ];

  // Execute update configurations with logging of fails and successes.
  if (!$thunderUpdater->executeUpdates($updateList)) {
    $successfulUpdate = FALSE;
  }

  // Set update checklist.
  if ($successfulUpdate) {
    $thunderUpdater->checklist()->markUpdatesSuccessful(['v1_1__thunder_admin_ux']);
  }
  else {
    $thunderUpdater->checklist()->markUpdatesFailed(['v1_1__thunder_admin_ux']);
  }

  // Output logged messages to related channel of update execution.
  return $updateLogger->output();
}

/**
 * Enable content_lock module.
 */
function thunder_update_8113() {

  /** @var \Drupal\thunder_updater\Updater $thunderUpdater */
  $thunderUpdater = \Drupal::service('thunder_updater');
  $updateLogger = $thunderUpdater->logger();

  if ($thunderUpdater->installModules(['v1_1__content_lock' => 'content_lock'])) {
    $updateLogger->info(t('content_lock module is successfully installed.'));

    if ($thunderUpdater->executeUpdates([['thunder', 'thunder__thunder_update_8113']])) {
      $thunderUpdater->checklist()->markUpdatesSuccessful(['v1_1__content_lock']);
    }
    else {
      $thunderUpdater->checklist()->markUpdatesFailed(['v1_1__content_lock']);
    }
  }

  // Output logged messages to related channel of update execution.
  return $thunderUpdater->logger()->output();
}

/**
 * Enable media_entity_pinterest module.
 */
function thunder_update_8114() {

  if (\Drupal::moduleHandler()->moduleExists('media_entity_pinterest')) {
    return;
  }

  /** @var \Drupal\thunder_updater\Updater $thunderUpdater */
  $thunderUpdater = \Drupal::service('thunder_updater');

  $successfulUpdate = TRUE;

  if ($thunderUpdater->installModules(['v1_1__media_entity_pinterest' => 'media_entity_pinterest'])) {

    // Order is important, because of dependencies.
    $importConfigs = [
      'paragraphs.paragraphs_type.pinterest',
      'media_entity.bundle.pinterest',
      'field.field.media.pinterest.field_url',
      'field.field.paragraph.pinterest.field_media',
      'core.entity_view_display.media.pinterest.default',
      'core.entity_view_display.media.pinterest.paragraph_preview',
      'core.entity_view_display.paragraph.pinterest.default',
      'core.entity_view_display.paragraph.pinterest.preview',
      'core.entity_form_display.media.pinterest.default',
      'core.entity_form_display.paragraph.pinterest.default',
    ];

    if ($thunderUpdater->importConfigs($importConfigs)) {
      if ($thunderUpdater->executeUpdates([['thunder', 'thunder__thunder_update_8114']])) {
        $thunderUpdater->checklist()->markUpdatesSuccessful(['v1_1__media_entity_pinterest']);
      }
      else {
        $successfulUpdate = FALSE;
      }
    }
    else {
      $successfulUpdate = FALSE;
    }
  }
  else {
    $successfulUpdate = FALSE;
  }

  if (!$successfulUpdate) {
    $thunderUpdater->checklist()->markUpdatesFailed(['v1_1__media_entity_pinterest']);
  }

  // Output logged messages to related channel of update execution.
  return $thunderUpdater->logger()->output();
}

/**
 * Update to Drupal 8.4.
 */
function thunder_update_8115() {
  /** @var \Drupal\thunder_updater\Updater $thunderUpdater */
  $thunderUpdater = \Drupal::service('thunder_updater');

  $successful = TRUE;
  if (!$thunderUpdater->executeUpdates([['thunder', 'thunder__thunder_update_8115']])) {
    $successful = FALSE;
  }

  if (\Drupal::moduleHandler()->moduleExists('thunder_riddle')) {
    if (!$thunderUpdater->executeUpdates([['thunder_riddle', 'thunder__thunder_update_8115']])) {
      $successful = FALSE;
    }
  }

  if ($successful) {
    $thunderUpdater->checklist()->markUpdatesSuccessful(['thunder__thunder_update_8115']);
  }
  else {
    $thunderUpdater->checklist()->markUpdatesFailed(['thunder__thunder_update_8115']);
  }

  // Output logged messages to related channel of update execution.
  return $thunderUpdater->logger()->output();
}

/**
 * Enable inline_form_errors module.
 */
function thunder_update_8116() {
  /** @var \Drupal\thunder_updater\Updater $thunderUpdater */
  $thunderUpdater = \Drupal::service('thunder_updater');
  $thunderUpdater->installModules(['thunder__thunder_update_8116' => 'inline_form_errors']);

  // Output logged messages to related channel of update execution.
  return $thunderUpdater->logger()->output();
}

/**
 * Enable paragraphs split text.
 */
function thunder_update_8117() {
  /** @var \Drupal\thunder_updater\Updater $thunderUpdater */
  $thunderUpdater = \Drupal::service('thunder_updater');
  if ($thunderUpdater->installModules(['thunder__thunder_update_8117' => 'paragraph_split_text'])) {
    $config = \Drupal::configFactory()->getEditable('editor.editor.basic_html');
    $items = $config->get('settings.toolbar.rows.0');
    if ($items) {
      foreach ($items as &$item) {
        if (!empty($item['name'] && $item['name'] === 'Tools')) {
          $item['items'][] = 'SplitTextBefore';

        }
      }
      $config->set('settings.toolbar.rows.0', $items)->save();
    }
    else {
      $thunderUpdater->checklist()->markUpdatesFailed(['thunder__thunder_update_8117']);
    }
  }
  // Output logged messages to related channel of update execution.
  return $thunderUpdater->logger()->output();
}

/**
 * Enable admin_toolbar_links_access_filter module.
 */
function thunder_update_8118() {
  /** @var \Drupal\thunder_updater\Updater $thunderUpdater */
  $thunderUpdater = \Drupal::service('thunder_updater');
  $thunderUpdater->installModules(['thunder__thunder_update_8118' => 'admin_toolbar_links_access_filter']);

  // Output logged messages to related channel of update execution.
  return $thunderUpdater->logger()->output();
}

/**
 * Enable redirect module.
 */
function thunder_update_8119() {
  /** @var \Drupal\thunder_updater\Updater $thunderUpdater */
  $thunderUpdater = \Drupal::service('thunder_updater');
  if ($thunderUpdater->installModules(['thunder__thunder_update_8119' => 'redirect'])) {
    if ($role = Role::load('seo')) {
      $role->grantPermission('administer redirects');
      $role->save();
    }
  }
  // Output logged messages to related channel of update execution.
  return $thunderUpdater->logger()->output();
}