social_course-8.x-2.11/modules/social_course_advanced/social_course_advanced.install

<?php

/**
 * @file
 * Requirements and update functions for the social_course_advanced module.
 */

use Drupal\Core\Config\FileStorage;
use Drupal\group\Entity\GroupRoleInterface;
use Drupal\group\GroupMembership;
use Drupal\social_group\Entity\Group;
use Drupal\user\Entity\User;
use Drupal\user\RoleInterface;

/**
 * Implements hook_install().
 *
 * Perform actions related to the installation of social_course_advanced.
 */
function social_course_advanced_install(): void {
  // Anonymous.
  $permissions[RoleInterface::ANONYMOUS_ID] = [
    'view public course_advanced group',
  ];
  // Authenticated.
  $permissions[RoleInterface::AUTHENTICATED_ID] = $permissions[RoleInterface::ANONYMOUS_ID];
  // Verified.
  $permissions['verified'] = [
    ...$permissions[RoleInterface::AUTHENTICATED_ID],
    ...[
      'view community course_advanced group',
      'view members course_advanced group',
    ],
  ];
  // Content manager.
  $permissions['contentmanager'] = [
    ...$permissions['verified'],
    ...['create course_advanced group'],
  ];
  // Site manager.
  $permissions['sitemanager'] = $permissions['contentmanager'];

  foreach ($permissions as $rid => $new_permissions) {
    user_role_grant_permissions($rid, $new_permissions);
  }

  // Enable Social Group Default Route module if it exists.
  if (!(\Drupal::moduleHandler()->moduleExists('social_group_default_route'))) {
    \Drupal::service('module_installer')->install(['social_group_default_route']);
  }
}

/**
 * Implements hook_update_dependencies().
 */
function social_course_advanced_update_dependencies(): array {
  // We need to run hook 13001, to install the new view.
  $dependencies['social_course_advanced'][13012] = [
    'social_course' => 13001,
  ];

  return $dependencies;
}

/**
 * Add the field_flexible_group_visibility field to the course_advanced group.
 */
function social_course_advanced_update_8001(): void {
  $config_path = \Drupal::service('extension.list.module')->getPath('module', 'social_course_advanced') . '/config/install';
  $source = new FileStorage($config_path);
  $config_storage = \Drupal::service('config.storage');

  $config_names = [
    'field.field.group.course_advanced.field_flexible_group_visibility',
    'field.field.group.course_advanced.field_group_allowed_visibility',
  ];

  foreach ($config_names as $config_name) {
    $data = $source->read($config_name);
    if (is_array($data)) {
      $config_storage->write($config_name, $data);
    }
  }
}

/**
 * Add view group permission for the anonymous users.
 */
function social_course_advanced_update_8004(): void {
  $config_name = 'group.role.course_advanced-anonymous';
  $config = \Drupal::configFactory()->getEditable($config_name);
  $permissions = $config->get('permissions');
  $permissions[] = 'view group';

  $config->set('permissions', $permissions)->save();
}

/**
 * Configuration update: change form display.
 */
function social_course_advanced_update_8005(): string {
  /** @var \Drupal\update_helper\Updater $updateHelper */
  $updateHelper = \Drupal::service('update_helper.updater');

  // Execute configuration update definitions with logging of success.
  $updateHelper->executeUpdate('social_course_advanced', 'social_course_advanced_update_8001');

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

/**
 * Set field_flexible_group_visibility as public by default.
 */
function social_course_advanced_update_8006(): void {
  $group_storage = \Drupal::entityTypeManager()->getStorage('group');
  $course_ids = $group_storage
    ->getQuery()
    ->accessCheck(TRUE)
    ->condition('type', 'course_advanced')
    ->execute();

  foreach ($course_ids as $course_id) {
    /** @var \Drupal\group\Entity\GroupInterface $course */
    $course = $group_storage->load($course_id);
    if ($course->hasField('field_flexible_group_visibility')) {
      $course->set('field_flexible_group_visibility', 'public');
      $course->save();
    }
  }
}

/**
 * Set field_group_allowed_visibility as community by default.
 */
function social_course_advanced_update_8007(): void {
  $group_storage = \Drupal::entityTypeManager()->getStorage('group');
  $course_ids = $group_storage
    ->getQuery()
    ->accessCheck(TRUE)
    ->condition('type', 'course_advanced')
    ->execute();

  foreach ($course_ids as $course_id) {
    /** @var \Drupal\group\Entity\GroupInterface $course */
    $course = $group_storage->load($course_id);
    if ($course->hasField('field_group_allowed_visibility')) {
      $course->set('field_group_allowed_visibility', ['community']);
      $course->save();
    }
  }
}

/**
 * Fix "Course Advanced" form display.
 */
function social_course_advanced_update_8008(): void {
  $config = \Drupal::configFactory()->getEditable('core.entity_form_display.group.course_advanced.default');
  $config->set('third_party_settings.field_group.group_date_and_time.parent_name', 'group_settings');
  $config->save();
}

/**
 * Remove redundant field group "Related courses" for "Course Advanced".
 */
function social_course_advanced_update_8901(): void {
  if ($group = field_group_load_field_group('group_related_courses', 'group', 'course_advanced', 'form', 'default')) {
    field_group_delete_field_group($group);
  }
}

/**
 * Add translations support for "Course Advanced" group type.
 */
function social_course_advanced_update_8902(): string {
  /** @var \Drupal\update_helper\Updater $updateHelper */
  $updateHelper = \Drupal::service('update_helper.updater');

  // Execute configuration update definitions with logging of success.
  $updateHelper->executeUpdate('social_course_advanced', 'social_course_advanced_update_8902');

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

/**
 * Configuration update: add path alias field.
 */
function social_course_advanced_update_8903(): string {
  /** @var \Drupal\update_helper\Updater $updateHelper */
  $updateHelper = \Drupal::service('update_helper.updater');

  // Execute configuration update definitions with logging of success.
  $updateHelper->executeUpdate('social_course_advanced', 'social_course_advanced_update_8903');

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

/**
 * Add a new view mode for group content for "Advanced Course" group type.
 */
function social_course_advanced_update_8904(): void {
  // Install new configs.
  $config_path = \Drupal::service('extension.list.module')->getPath('module', 'social_course_advanced') . '/config/install';
  $source = new FileStorage($config_path);
  $config_storage = \Drupal::service('config.storage');

  $config_names = [
    'core.entity_view_display.group_content.course_advanced-group_node-event.activity',
    'core.entity_view_display.group_content.course_advanced-group_node-topic.activity',
  ];

  foreach ($config_names as $name) {
    $data = $source->read($name);
    if (is_array($data)) {
      $config_storage->write($name, $data);
    }
  }
}

/**
 * Disable revisions for Advanced Courses.
 */
function social_course_advanced_update_8905(): string {
  /** @var \Drupal\update_helper\Updater $updateHelper */
  $updateHelper = \Drupal::service('update_helper.updater');

  // Execute configuration update definitions with logging of success.
  $updateHelper->executeUpdate('social_course_advanced', 'social_course_advanced_update_8905');

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

/**
 * Replace deprecated group permissions for course_advanced.
 */
function social_course_advanced_update_13001(): void {
  _social_course_update_group_permissions('course_advanced');
}

/**
 * Move group_admin to group_manager group role for course_advanced.
 *
 * @param array $sandbox
 *   Stores information for batch updates. See above for more information.
 *
 * @return string
 *   Displays a message about results to user after the update has completed.
 */
function social_course_advanced_update_13002(array &$sandbox): string {
  if (!isset($sandbox['progress'])) {
    $db = \Drupal::database();

    // Fetch users with group_admin role that should be updated.
    $query = $db->select('group_content__group_roles', 'gcgr');
    $query->addField('gcgr', 'entity_id');
    $query->addField('grfd', 'entity_id', 'uid');
    $query->addField('grfd', 'gid');
    $query->condition('gcgr.group_roles_target_id', 'course_advanced-group_admin');

    $query->join('group_relationship_field_data', 'grfd', 'grfd.id = gcgr.entity_id');

    $sandbox['ids'] = $query->execute()->fetchAllAssoc('entity_id');

    $sandbox['max'] = count($sandbox['ids']);
    $sandbox['progress'] = 0;
  }
  $items = array_slice($sandbox['ids'], $sandbox['progress'], 25);
  foreach ($items as $item) {
    $updated = FALSE;
    $account = User::load($item->uid);
    $group = Group::load($item->gid);
    $manager_role = 'course_advanced-group_manager';

    /** @var \Drupal\group\GroupMembership $membership */
    $membership = $group->getMember($account);

    if (
      $membership instanceof GroupMembership &&
      $account instanceof UserInterface &&
      $group instanceof GroupInterface
    ) {
      $group_relationship = $membership->getGroupRelationship();
      $member_assigned_roles = array_column($group_relationship->get('group_roles')->getValue(), 'target_id');

      // Apply group role update only for SM/CM role.
      if ($account->hasRole('sitemanager') || $account->hasRole('contentmanager')) {

        // Assign owner a GM role group.
        if ($account->id() === $group->getOwnerId()) {
          // Only if it doesn't assigned yet.
          if (!in_array($manager_role, $member_assigned_roles)) {
            $member_assigned_roles[] = $manager_role;
            $member_assigned_roles = array_map(function ($member_assigned_role) {
              return ['target_id' => $member_assigned_role];
            }, $member_assigned_roles);
            $updated = TRUE;
          }
        }
      }
      // Remove deprecated Group Admin role.
      $admin_role = 'course_advanced-group_admin';
      if (in_array($admin_role, $member_assigned_roles)) {
        $key = array_search($admin_role, $member_assigned_roles);
        unset($member_assigned_roles[$key]);

        $member_assigned_roles = array_map(function ($member_assigned_role) {
          return ['target_id' => $member_assigned_role];
        }, $member_assigned_roles);
        $updated = TRUE;
      }

      // Save updated assigned roles.
      if ($updated) {
        $group_relationship->set('group_roles', $member_assigned_roles);
        $group_relationship->save();
      }
    }
    $sandbox['progress']++;
  }
  $sandbox['#finished'] = empty($sandbox['max']) ? 1 : ($sandbox['progress'] / $sandbox['max']);
  // Show a status update for the current progress.
  return t("Checked @progress from @max users.", [
    '@progress' => $sandbox['progress'],
    '@max' => $sandbox['max'],
  ]);
}

/**
 * Create Admin/CM/CS insider roles and delete "group admin" role.
 */
function social_course_advanced_update_13003(): string {
  $config_factory = \Drupal::configFactory();
  $config_path = \Drupal::service('extension.list.module')->getPath('social_course_advanced') . '/config/static';
  $source = new FileStorage($config_path);

  // Created new roles.
  foreach (['admin', 'cm', 'sm'] as $id) {
    $config_name = "group.role.course_advanced-{$id}-insider";
    $data = $source->read($config_name);
    if (is_array($data)) {
      $config_factory->getEditable($config_name)
        ->setData($data)
        ->save();
    }
  }

  // Delete deprecated role.
  $config_factory->getEditable('group.role.course_advanced-group_admin')->delete();

  // Update CM role and related configs.
  /** @var \Drupal\update_helper\Updater $updater */
  $updater = \Drupal::service('update_helper.updater');
  // Execute configuration update definitions with logging of success.
  $updater->executeUpdate('social_course_advanced', __FUNCTION__);
  // Output logged messages to related channel of update execution.
  return $updater->logger()->output();
}

/**
 * Allow course leaders to perform CRUD operations on "Article" and "Video".
 */
function social_course_advanced_update_13004(): void {
  /** @var \Drupal\group\Entity\GroupRole $course_leader */
  $course_leader = \Drupal::entityTypeManager()
    ->getStorage('group_role')
    ->load('course_advanced-group_manager');
  $course_leader->grantPermissions([
    'create course_article',
    'view course_article',
    'update course_article',
    'delete course_article',
    'create course_video',
    'view course_video',
    'update course_video',
    'delete course_video',
  ]);
  $course_leader->save();
}

/**
 * Add 'Verified' group role.
 */
function social_course_advanced_update_13005(): string {
  /** @var \Drupal\update_helper\Updater $updateHelper */
  $updateHelper = \Drupal::service('update_helper.updater');

  // Execute configuration update definitions with logging of success.
  $updateHelper->executeUpdate('social_course_advanced', __FUNCTION__);

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

/**
 * Revoke group permissions for Outsider role.
 */
function social_course_advanced_update_13006(): void {
  $roles_permissions = [
    'course_advanced-outsider' => [
      'view group_membership relationship',
    ],
  ];

  foreach ($roles_permissions as $role_id => $permissions) {
    /** @var \Drupal\group\Entity\GroupRoleInterface $role */
    $role = \Drupal::entityTypeManager()->getStorage('group_role')->load($role_id);

    foreach ($permissions as $permission) {
      $role->revokePermission($permission);
    }

    $role->save();
  }
}

/**
 * Improve "Small teaser" view mode.
 */
function social_course_advanced_update_13007(): string {
  /** @var \Drupal\update_helper\Updater $updateHelper */
  $updateHelper = \Drupal::service('update_helper.updater');
  $updateHelper->executeUpdate('social_course_advanced', __FUNCTION__);
  return $updateHelper->logger()->output();
}

/**
 * Revoke "Join Group" permission for Authenticated (outsider) group role.
 */
function social_course_advanced_update_13008(): void {
  $group_authenticated_role = \Drupal::entityTypeManager()
    ->getStorage('group_role')
    ->load('course_advanced-outsider');

  if ($group_authenticated_role instanceof GroupRoleInterface) {
    $group_authenticated_role->revokePermissions([
      'join group',
      'request group membership',
    ])->save();
  }

}

/**
 * Grant permissions for Verified (outsider) group role.
 */
function social_course_advanced_update_13009(): void {
  $group_verified_role = \Drupal::entityTypeManager()
    ->getStorage('group_role')
    ->load('course_advanced-verified');

  if ($group_verified_role instanceof GroupRoleInterface) {
    $group_verified_role->grantPermissions([
      'join group',
      'request group membership',
    ])->save();
  }

}

/**
 * Grant permissions for Verified, Anonymous and Authenticated group role.
 */
function social_course_advanced_update_13010(): void {
  $roles_permissions = [
    'course_advanced-anonymous' => [
      'view group_node:event entity',
      'view group_node:event relationship',
      'view group_node:topic entity',
      'view group_node:topic relationship',
      'view group_node:course_section entity',
      'view group_node:course_section relationship',
    ],
    'course_advanced-outsider' => [
      'view group_node:event entity',
      'view group_node:event relationship',
      'view group_node:topic entity',
      'view group_node:topic relationship',
    ],
    'course_advanced-verified' => [
      'view group_node:event entity',
      'view group_node:event relationship',
      'view group_node:topic entity',
      'view group_node:topic relationship',
    ],
  ];

  foreach ($roles_permissions as $role => $permissions) {
    $role = \Drupal::entityTypeManager()
      ->getStorage('group_role')
      ->load($role);

    if ($role instanceof GroupRoleInterface) {
      $role->grantPermissions($permissions)->save();
    }
  }

}

/**
 * Enable Social Group Default Route module if it exists.
 */
function social_course_advanced_update_13011(): void {
  if (!(\Drupal::moduleHandler()->moduleExists('social_group_default_route'))) {
    \Drupal::service('module_installer')->install(['social_group_default_route']);
  }
}

/**
 * Grant new permissions to access to Advanced Courses.
 */
function social_course_advanced_update_13012(): void {
  $permissions[RoleInterface::ANONYMOUS_ID] =
  $permissions[RoleInterface::AUTHENTICATED_ID] = ['view public course_advanced group'];
  $permissions['verified'] = [
    ...$permissions[RoleInterface::AUTHENTICATED_ID],
    ...[
      'view community course_advanced group',
      'view members course_advanced group',
    ],
  ];
  $permissions['contentmanager'] = $permissions['sitemanager'] = $permissions['verified'];

  foreach ($permissions as $rid => $new_permissions) {
    user_role_grant_permissions($rid, $new_permissions);
  }
}

/**
 * Update the new hubs view.
 */
function social_course_advanced_update_13013(): string {
  /** @var \Drupal\update_helper\UpdaterInterface $update_helper */
  $update_helper = \Drupal::service('update_helper.updater');
  $update_helper->executeUpdate('social_course_advanced', __FUNCTION__);
  return $update_helper->logger()->output();
}

/**
 * Update the group visibility field description.
 */
function social_course_advanced_update_13014(): void {
  $field_config = \Drupal::configFactory()
    ->getEditable('field.field.group.course_advanced.field_flexible_group_visibility');

  $field_config->set('label', 'Visibility');
  $field_config->set('description', 'Who can find and view your course');
  $field_config->save();
}

/**
 * Add third_party_settings for advanced course group roles.
 */
function social_course_advanced_update_13015(): string {
  /** @var \Drupal\update_helper\UpdaterInterface $update_helper */
  $update_helper = \Drupal::service('update_helper.updater');
  $update_helper->executeUpdate('social_course_advanced', __FUNCTION__);
  return $update_helper->logger()->output();
}