You are here

Home » API reference » Group 8 » GroupRoleStorage.php

class GroupRoleStorage in Group 8

Same name and namespace in other branches
  1. 2.0.x src/Entity/Storage/GroupRoleStorage.php \Drupal\group\Entity\Storage\GroupRoleStorage

Defines the storage handler class for group role entities.

This extends the base storage class, adding required special handling for loading group role entities based on user and group information.

Hierarchy

Expanded class hierarchy of GroupRoleStorage

File

src/Entity/Storage/GroupRoleStorage.php, line 25

Namespace

Drupal\group\Entity\Storage
View source 
class GroupRoleStorage extends ConfigEntityStorage implements GroupRoleStorageInterface {

  /**
   * Static cache of a user's group role IDs.
   *
   * @var array
   */
  protected $userGroupRoleIds = [];

  /**
   * The entity type manager.
   *
   * @var \Drupal\Core\Entity\EntityTypeManagerInterface
   */
  protected $entityTypeManager;

  /**
   * The group role synchronizer service.
   *
   * @var \Drupal\group\GroupRoleSynchronizerInterface
   */
  protected $groupRoleSynchronizer;

  /**
   * The group membership loader.
   *
   * @var \Drupal\group\GroupMembershipLoaderInterface
   */
  protected $groupMembershipLoader;

  /**
   * Constructs a GroupRoleStorage object.
   *
   * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
   *   The entity type manager.
   * @param \Drupal\group\GroupRoleSynchronizerInterface $group_role_synchronizer
   *   The group role synchronizer service.
   * @param \Drupal\group\GroupMembershipLoaderInterface $group_membership_loader
   *   The group membership loader.
   * @param \Drupal\Core\Entity\EntityTypeInterface $entity_type
   *   The entity type definition.
   * @param \Drupal\Core\Config\ConfigFactoryInterface $config_factory
   *   The config factory service.
   * @param \Drupal\Component\Uuid\UuidInterface $uuid_service
   *   The UUID service.
   * @param \Drupal\Core\Language\LanguageManagerInterface $language_manager
   *   The language manager.
   * @param \Drupal\Core\Cache\MemoryCache\MemoryCacheInterface $memory_cache
   *   The memory cache backend.
   */
  public function __construct(EntityTypeManagerInterface $entity_type_manager, GroupRoleSynchronizerInterface $group_role_synchronizer, GroupMembershipLoaderInterface $group_membership_loader, EntityTypeInterface $entity_type, ConfigFactoryInterface $config_factory, UuidInterface $uuid_service, LanguageManagerInterface $language_manager, MemoryCacheInterface $memory_cache) {
    parent::__construct($entity_type, $config_factory, $uuid_service, $language_manager, $memory_cache);
    $this->entityTypeManager = $entity_type_manager;
    $this->groupRoleSynchronizer = $group_role_synchronizer;
    $this->groupMembershipLoader = $group_membership_loader;
  }

  /**
   * {@inheritdoc}
   */
  public static function createInstance(ContainerInterface $container, EntityTypeInterface $entity_type) {
    return new static($container
      ->get('entity_type.manager'), $container
      ->get('group_role.synchronizer'), $container
      ->get('group.membership_loader'), $entity_type, $container
      ->get('config.factory'), $container
      ->get('uuid'), $container
      ->get('language_manager'), $container
      ->get('entity.memory_cache'));
  }

  /**
   * {@inheritdoc}
   */
  public function loadByUserAndGroup(AccountInterface $account, GroupInterface $group, $include_implied = TRUE) {
    $uid = $account
      ->id();
    $gid = $group
      ->id();
    $key = $include_implied ? 'include' : 'exclude';
    if (!isset($this->userGroupRoleIds[$uid][$gid][$key])) {
      $ids = [];

      // Get the IDs from the 'group_roles' field, without loading the roles.
      if ($membership = $this->groupMembershipLoader
        ->load($group, $account)) {
        foreach ($membership
          ->getGroupContent()->group_roles as $group_role_ref) {
          $ids[] = $group_role_ref->target_id;
        }
      }

      // Add the implied group role IDs.
      if ($include_implied) {
        $group_type = $group
          ->getGroupType();
        if ($membership !== FALSE) {
          $ids[] = $group_type
            ->getMemberRoleId();
        }
        elseif ($account
          ->isAnonymous()) {
          $ids[] = $group_type
            ->getAnonymousRoleId();
        }
        else {
          $ids[] = $group_type
            ->getOutsiderRoleId();
          foreach ($account
            ->getRoles(TRUE) as $role_id) {
            $ids[] = $this->groupRoleSynchronizer
              ->getGroupRoleId($group_type
              ->id(), $role_id);
          }
        }
      }
      $this->userGroupRoleIds[$uid][$gid][$key] = $ids;
    }
    return $this
      ->loadMultiple($this->userGroupRoleIds[$uid][$gid][$key]);
  }

  /**
   * {@inheritdoc}
   */
  public function loadSynchronizedByGroupTypes(array $group_type_ids) {
    return $this
      ->loadMultiple($this->groupRoleSynchronizer
      ->getGroupRoleIdsByGroupTypes($group_type_ids));
  }

  /**
   * {@inheritdoc}
   */
  public function loadSynchronizedByUserRoles(array $role_ids) {
    return $this
      ->loadMultiple($this->groupRoleSynchronizer
      ->getGroupRoleIdsByUserRoles($role_ids));
  }

  /**
   * {@inheritdoc}
   */
  public function createInternal($group_type_ids = NULL) {

    /** @var \Drupal\group\Entity\GroupTypeInterface[] $group_types */
    $group_types = $this->entityTypeManager
      ->getStorage('group_type')
      ->loadMultiple($group_type_ids);

    // Return early if there are no group types to create roles for.
    if (empty($group_types)) {
      return;
    }
    $definitions = [];
    foreach ($group_types as $group_type_id => $group_type) {

      // Build a list of group role definitions but do not save them yet so we
      // can check whether they already exist in bulk instead of trying to find
      // out on an individual basis here.
      $definitions[$group_type
        ->getAnonymousRoleId()] = [
        'id' => $group_type
          ->getAnonymousRoleId(),
        'label' => $this
          ->t('Anonymous'),
        'weight' => -102,
        'internal' => TRUE,
        'audience' => 'anonymous',
        'group_type' => $group_type_id,
      ];
      $definitions[$group_type
        ->getOutsiderRoleId()] = [
        'id' => $group_type
          ->getOutsiderRoleId(),
        'label' => $this
          ->t('Outsider'),
        'weight' => -101,
        'internal' => TRUE,
        'audience' => 'outsider',
        'group_type' => $group_type_id,
      ];
      $definitions[$group_type
        ->getMemberRoleId()] = [
        'id' => $group_type
          ->getMemberRoleId(),
        'label' => $this
          ->t('Member'),
        'weight' => -100,
        'internal' => TRUE,
        'group_type' => $group_type_id,
      ];
    }

    // See if the roles we just defined already exist.
    $query = $this
      ->getQuery();
    $query
      ->condition('id', array_keys($definitions));

    // Create the group roles that do not exist yet.
    foreach (array_diff_key($definitions, $query
      ->execute()) as $definition) {
      $this
        ->save($this
        ->create($definition));
    }
  }

  /**
   * {@inheritdoc}
   */
  public function createSynchronized($group_type_ids = NULL, $role_ids = NULL) {

    // Load all possible group type IDs if none were provided.
    if (empty($group_type_ids)) {
      $group_type_ids = $this->entityTypeManager
        ->getStorage('group_type')
        ->getQuery()
        ->execute();
    }

    // Return early if there are no group types to create roles for.
    if (empty($group_type_ids)) {
      return;
    }

    /** @var \Drupal\User\RoleInterface[] $user_roles */
    $user_roles = $this->entityTypeManager
      ->getStorage('user_role')
      ->loadMultiple($role_ids);
    $definitions = [];
    foreach (array_keys($user_roles) as $role_id) {

      // We do not synchronize the 'anonymous' or 'authenticated' user roles as
      // they are already taken care of by the 'anonymous' and 'outsider'
      // internal group roles.
      if ($role_id == 'anonymous' || $role_id == 'authenticated') {
        continue;
      }

      // Build a list of group role definitions but do not save them yet so we
      // can check whether they already exist in bulk instead of trying to find
      // out on an individual basis here.
      foreach ($group_type_ids as $group_type_id) {
        $group_role_id = $this->groupRoleSynchronizer
          ->getGroupRoleId($group_type_id, $role_id);
        $definitions[$group_role_id] = [
          'id' => $group_role_id,
          'label' => $user_roles[$role_id]
            ->label(),
          'weight' => $user_roles[$role_id]
            ->getWeight(),
          'internal' => TRUE,
          'audience' => 'outsider',
          'group_type' => $group_type_id,
          'permissions_ui' => FALSE,
          // Adding the user role as an enforced dependency will automatically
          // delete any synchronized group role when its corresponding user role
          // is deleted.
          'dependencies' => [
            'enforced' => [
              'config' => [
                $user_roles[$role_id]
                  ->getConfigDependencyName(),
              ],
            ],
          ],
        ];
      }
    }

    // See if the roles we just defined already exist.
    $query = $this
      ->getQuery();
    $query
      ->condition('id', array_keys($definitions));

    // Create the group roles that do not exist yet.
    foreach (array_diff_key($definitions, $query
      ->execute()) as $definition) {
      $this
        ->save($this
        ->create($definition));
    }
  }

  /**
   * {@inheritdoc}
   */
  public function updateSynchronizedLabels(RoleInterface $role) {
    $group_roles = $this
      ->loadMultiple($this->groupRoleSynchronizer
      ->getGroupRoleIdsByUserRole($role
      ->id()));
    foreach ($group_roles as $group_role) {
      $group_role
        ->set('label', $role
        ->label());
      $this
        ->save($group_role);
    }
  }

  /**
   * {@inheritdoc}
   */
  public function resetUserGroupRoleCache(AccountInterface $account, GroupInterface $group = NULL) {
    $uid = $account
      ->id();
    if (isset($group)) {
      unset($this->userGroupRoleIds[$uid][$group
        ->id()]);
    }
    else {
      unset($this->userGroupRoleIds[$uid]);
    }
  }

}

Members

Namesort descending Modifiers Type Description Overrides
ConfigEntityStorage::$configFactory protected property The config factory service.
ConfigEntityStorage::$configStorage protected property The config storage service.
ConfigEntityStorage::$entities protected property Static cache of entities, keyed first by entity ID, then by an extra key.
ConfigEntityStorage::$languageManager protected property The language manager.
ConfigEntityStorage::$overrideFree protected property Determines if the underlying configuration is retrieved override free.
ConfigEntityStorage::$uuidKey protected property Name of entity's UUID database table field, if it supports UUIDs. Overrides EntityStorageBase::$uuidKey
ConfigEntityStorage::buildCacheId protected function Builds the cache ID for the passed in entity ID. Overrides EntityStorageBase::buildCacheId
ConfigEntityStorage::createFromStorageRecord public function Creates a configuration entity from storage values. Overrides ConfigEntityStorageInterface::createFromStorageRecord
ConfigEntityStorage::deleteRevision public function Delete a specific entity revision. Overrides EntityStorageInterface::deleteRevision
ConfigEntityStorage::doCreate protected function Performs storage-specific creation of entities. Overrides EntityStorageBase::doCreate
ConfigEntityStorage::doDelete protected function Performs storage-specific entity deletion. Overrides EntityStorageBase::doDelete
ConfigEntityStorage::doLoadMultiple protected function Performs storage-specific loading of entities. Overrides EntityStorageBase::doLoadMultiple
ConfigEntityStorage::doSave protected function Performs storage-specific saving of the entity. Overrides EntityStorageBase::doSave
ConfigEntityStorage::getIDFromConfigName public static function Extracts the configuration entity ID from the full configuration name. Overrides ConfigEntityStorageInterface::getIDFromConfigName
ConfigEntityStorage::getPrefix protected function Returns the prefix used to create the configuration name.
ConfigEntityStorage::getQueryServiceName protected function Gets the name of the service for the query for this entity storage. Overrides EntityStorageBase::getQueryServiceName
ConfigEntityStorage::has protected function Determines if this entity already exists in storage. Overrides EntityStorageBase::has
ConfigEntityStorage::hasData public function Determines if the storage contains any data. Overrides EntityStorageBase::hasData
ConfigEntityStorage::importCreate public function Creates entities upon synchronizing configuration changes. Overrides ImportableEntityStorageInterface::importCreate 1
ConfigEntityStorage::importDelete public function Delete entities upon synchronizing configuration changes. Overrides ImportableEntityStorageInterface::importDelete 2
ConfigEntityStorage::importRename public function Renames entities upon synchronizing configuration changes. Overrides ImportableEntityStorageInterface::importRename
ConfigEntityStorage::importUpdate public function Updates entities upon synchronizing configuration changes. Overrides ImportableEntityStorageInterface::importUpdate 1
ConfigEntityStorage::invokeHook protected function Invokes a hook on behalf of the entity. Overrides EntityStorageBase::invokeHook
ConfigEntityStorage::loadMultipleOverrideFree public function Loads one or more entities in their original form without overrides. Overrides ConfigEntityStorageInterface::loadMultipleOverrideFree
ConfigEntityStorage::loadOverrideFree public function Loads one entity in their original form without overrides. Overrides ConfigEntityStorageInterface::loadOverrideFree
ConfigEntityStorage::loadRevision public function Load a specific entity revision. Overrides EntityStorageInterface::loadRevision
ConfigEntityStorage::mapToStorageRecord protected function Maps from an entity object to the storage record. 3
ConfigEntityStorage::MAX_ID_LENGTH constant Length limit of the configuration entity ID. 1
ConfigEntityStorage::save public function Implements Drupal\Core\Entity\EntityStorageInterface::save(). Overrides EntityStorageBase::save
ConfigEntityStorage::updateFromStorageRecord public function Updates a configuration entity from storage values. Overrides ConfigEntityStorageInterface::updateFromStorageRecord
ConfigEntityStorage::_doCreateFromStorageRecord protected function Helps create a configuration entity from storage values.
DependencySerializationTrait::$_entityStorages protected property An array of entity type IDs keyed by the property name of their storages.
DependencySerializationTrait::$_serviceIds protected property An array of service IDs keyed by property name used for serialization.
DependencySerializationTrait::__sleep public function 1
DependencySerializationTrait::__wakeup public function 2
EntityHandlerBase::$moduleHandler protected property The module handler to invoke hooks on. 2
EntityHandlerBase::moduleHandler protected function Gets the module handler. 2
EntityHandlerBase::setModuleHandler public function Sets the module handler for this handler.
EntityStorageBase::$entityClass protected property Name of the entity class.
EntityStorageBase::$entityType protected property Information about the entity type.
EntityStorageBase::$entityTypeId protected property Entity type ID for this storage.
EntityStorageBase::$idKey protected property Name of the entity's ID field in the entity database table.
EntityStorageBase::$langcodeKey protected property The name of the entity langcode property. 1
EntityStorageBase::$memoryCache protected property The memory cache.
EntityStorageBase::$memoryCacheTag protected property The memory cache cache tag.
EntityStorageBase::$uuidService protected property The UUID service. 1
EntityStorageBase::buildPropertyQuery protected function Builds an entity query. 1
EntityStorageBase::create public function Constructs a new entity object, without permanently saving it. Overrides EntityStorageInterface::create 1
EntityStorageBase::delete public function Deletes permanently saved entities. Overrides EntityStorageInterface::delete 2
EntityStorageBase::doPostSave protected function Performs post save entity processing. 1
EntityStorageBase::doPreSave protected function Performs presave entity processing. 1
EntityStorageBase::getAggregateQuery public function Gets an aggregated query instance. Overrides EntityStorageInterface::getAggregateQuery
EntityStorageBase::getEntityType public function Gets the entity type definition. Overrides EntityStorageInterface::getEntityType
EntityStorageBase::getEntityTypeId public function Gets the entity type ID. Overrides EntityStorageInterface::getEntityTypeId
EntityStorageBase::getFromStaticCache protected function Gets entities from the static cache.
EntityStorageBase::getQuery public function Gets an entity query instance. Overrides EntityStorageInterface::getQuery
EntityStorageBase::load public function Loads one entity. Overrides EntityStorageInterface::load 2
EntityStorageBase::loadByProperties public function Load entities by their property values. Overrides EntityStorageInterface::loadByProperties 3
EntityStorageBase::loadMultiple public function Loads one or more entities. Overrides EntityStorageInterface::loadMultiple 1
EntityStorageBase::loadUnchanged public function Loads an unchanged entity from the database. Overrides EntityStorageInterface::loadUnchanged 1
EntityStorageBase::mapFromStorageRecords protected function Maps from storage records to entity objects. 4
EntityStorageBase::postLoad protected function Attaches data to entities upon loading.
EntityStorageBase::preLoad protected function Gathers entities from a 'preload' step. 1
EntityStorageBase::resetCache public function Resets the internal, static entity cache. Overrides EntityStorageInterface::resetCache 2
EntityStorageBase::restore public function Restores a previously saved entity. Overrides EntityStorageInterface::restore 1
EntityStorageBase::setStaticCache protected function Stores entities in the static entity cache.
EntityStorageInterface::FIELD_LOAD_CURRENT constant Load the most recent version of an entity's field data.
EntityStorageInterface::FIELD_LOAD_REVISION constant Load the version of an entity's field data specified in the entity.
GroupRoleStorage::$entityTypeManager protected property The entity type manager.
GroupRoleStorage::$groupMembershipLoader protected property The group membership loader.
GroupRoleStorage::$groupRoleSynchronizer protected property The group role synchronizer service.
GroupRoleStorage::$userGroupRoleIds protected property Static cache of a user's group role IDs.
GroupRoleStorage::createInstance public static function Instantiates a new instance of this entity handler. Overrides ConfigEntityStorage::createInstance
GroupRoleStorage::createInternal public function Creates internal group roles for group types. Overrides GroupRoleStorageInterface::createInternal
GroupRoleStorage::createSynchronized public function Creates group roles for all user roles. Overrides GroupRoleStorageInterface::createSynchronized
GroupRoleStorage::loadByUserAndGroup public function Retrieves all GroupRole entities for a user within a group. Overrides GroupRoleStorageInterface::loadByUserAndGroup
GroupRoleStorage::loadSynchronizedByGroupTypes public function Retrieves all synchronized GroupRole entities by group types. Overrides GroupRoleStorageInterface::loadSynchronizedByGroupTypes
GroupRoleStorage::loadSynchronizedByUserRoles public function Retrieves all synchronized GroupRole entities by user roles. Overrides GroupRoleStorageInterface::loadSynchronizedByUserRoles
GroupRoleStorage::resetUserGroupRoleCache public function Resets the internal, static cache used by ::loadByUserAndGroup(). Overrides GroupRoleStorageInterface::resetUserGroupRoleCache
GroupRoleStorage::updateSynchronizedLabels public function Updates the label of all group roles for a user role. Overrides GroupRoleStorageInterface::updateSynchronizedLabels
GroupRoleStorage::__construct public function Constructs a GroupRoleStorage object. Overrides ConfigEntityStorage::__construct
StringTranslationTrait::$stringTranslation protected property The string translation service. 1
StringTranslationTrait::formatPlural protected function Formats a string containing a count of items.
StringTranslationTrait::getNumberOfPlurals protected function Returns the number of plurals supported by a given language.
StringTranslationTrait::getStringTranslation protected function Gets the string translation service.
StringTranslationTrait::setStringTranslation public function Sets the string translation service to use. 2
StringTranslationTrait::t protected function Translates a string to the current language or to a given language.