Return partially populated OgRole entities when gathering default roles

og.services.yml

@@ -2,14 +2,17 @@ services:
   og.access:
     class: Drupal\og\OgAccess
     arguments: ['@config.factory', '@current_user', '@module_handler']
+  og.default_role_event:
+    class: Drupal\og\Event\DefaultRoleEvent
+    arguments: ['@entity_type.manager']
   og.event_subscriber:
     class: Drupal\og\EventSubscriber\OgEventSubscriber
     arguments: ['@og.permission_manager']
     tags:
       - { name: 'event_subscriber' }
   og.group.manager:
     class: Drupal\og\GroupManager
-    arguments: ['@config.factory', '@entity_type.manager', '@entity_type.bundle.info', '@event_dispatcher', '@state']
+    arguments: ['@config.factory', '@entity_type.manager', '@entity_type.bundle.info', '@event_dispatcher', '@og.default_role_event', '@state']
   og.permissions:
     class: Drupal\og\OgPermissionHandler
     arguments: ['@module_handler', '@string_translation', '@controller_resolver']

src/Entity/OgRole.php

@@ -174,11 +174,42 @@ public function setRoleType($role_type) {
     return $this->set('role_type', $role_type);
   }
 
+  /**
+   * {@inheritdoc}
+   */
+  public function getName() {
+    // If the name is not set yet, try to derive it from the ID.
+    if (empty($this->name) && !empty($this->id())) {
+      list(, , $name) = explode('-', $this->id());
+      $this->setName($name);
+    }
+    return $this->name;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setName($name) {
+    $this->name = $name;
+    return $this;
+  }
+
   /**
    * {@inheritdoc}
    */
   public function save() {
-    if ($this->isNew()) {
+    // The ID of a new OgRole has to consist of the entity type ID, bundle ID
+    // and role name, separated by dashes.
+    if ($this->isNew() && !empty($this->id())) {
+      list($entity_type_id, $bundle_id, $name) = explode('-', $this->id());
+      if ($entity_type_id !== $this->getGroupType() || $bundle_id !== $this->getGroupBundle() || $name !== $this->getName()) {
+        throw new ConfigValueException('The ID should consist of the group entity type ID, group bundle ID and role name, separated by dashes.');
+      }
+    }
+
+    // If a new OgRole is saved and the ID is not set, construct the ID from
+    // the entity type ID, bundle ID and role name.
+    if ($this->isNew() && empty($this->id())) {
       if (empty($this->getGroupType())) {
         throw new ConfigValueException('The group type can not be empty.');
       }
@@ -187,6 +218,10 @@ public function save() {
         throw new ConfigValueException('The group bundle can not be empty.');
       }
 
+      if (empty($this->getName())) {
+        throw new ConfigValueException('The role name can not be empty.');
+      }
+
       // When assigning a role to group we need to add a prefix to the ID in
       // order to prevent duplicate IDs.
       $prefix = $this->getGroupType() . '-' . $this->getGroupBundle() . '-';
@@ -195,7 +230,7 @@ public function save() {
         $prefix .= $this->getGroupId() . '-';
       }
 
-      $this->id = $prefix . $this->id();
+      $this->id = $prefix . $this->getName();
     }
 
     parent::save();
@@ -234,30 +269,26 @@ public function delete() {
   }
 
   /**
-   * Returns default properties for the default OG roles.
-   *
-   * These are the two roles that are required by every group: the 'member' and
-   * 'non-member' roles.
-   *
-   * All other default roles are provided by DefaultRoleEvent.
-   *
-   * @return array
-   *   An array of properties, keyed by OG role.
-   *
-   * @see \Drupal\og\Event\DefaultRoleEventInterface
-   * @see \Drupal\og\GroupManager::getDefaultRoles()
+   * {@inheritdoc}
    */
-  public static function getDefaultRoles() {
-    return [
+  public static function getDefaultRoleProperties($default_role_name) {
+    if (!in_array($default_role_name, [self::ANONYMOUS, self::AUTHENTICATED])) {
+      throw new \InvalidArgumentException('Invalid role name.');
+    }
+    $default_properties = [
       self::ANONYMOUS => [
         'role_type' => OgRoleInterface::ROLE_TYPE_REQUIRED,
         'label' => 'Non-member',
+        'name' => self::ANONYMOUS,
       ],
       self::AUTHENTICATED => [
         'role_type' => OgRoleInterface::ROLE_TYPE_REQUIRED,
         'label' => 'Member',
+        'name' => self::AUTHENTICATED,
       ],
     ];
+
+    return $default_properties[$default_role_name];
   }
 
   /**

src/Event/DefaultRoleEvent.php

@@ -2,6 +2,7 @@
 
 namespace Drupal\og\Event;
 
+use Drupal\Core\Entity\EntityTypeManagerInterface;
 use Drupal\og\OgRoleInterface;
 use Symfony\Component\EventDispatcher\Event;
 
@@ -21,6 +22,23 @@ class DefaultRoleEvent extends Event implements DefaultRoleEventInterface {
    */
   protected $roles = [];
 
+  /**
+   * The OG Role entity storage handler.
+   *
+   * @var \Drupal\Core\Entity\EntityStorageInterface
+   */
+  protected $ogRoleStorage;
+
+  /**
+   * Constructs a DefaultRoleEvent object.
+   *
+   * @var \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
+   *   The entity type manager.
+   */
+  public function __construct(EntityTypeManagerInterface $entity_type_manager) {
+    $this->ogRoleStorage = $entity_type_manager->getStorage('og_role');
+  }
+
   /**
    * {@inheritdoc}
    */
@@ -41,43 +59,46 @@ public function getRoles() {
   /**
    * {@inheritdoc}
    */
-  public function addRole($name, array $properties) {
-    if (array_key_exists($name, $this->roles)) {
-      throw new \InvalidArgumentException("The '$name' role already exists.");
-    }
-    $this->validate($name, $properties);
+  public function addRole(array $properties) {
+    $this->validate($properties);
 
-    // Provide default value for the role type.
-    if (empty($properties['role_type'])) {
-      $properties['role_type'] = OgRoleInterface::ROLE_TYPE_STANDARD;
+    if (array_key_exists($properties['name'], $this->roles)) {
+      throw new \InvalidArgumentException("The '{$properties['name']}' role already exists.");
     }
 
-    $this->roles[$name] = $properties;
+    // Provide default values.
+    $properties += [
+      'role_type' => OgRoleInterface::ROLE_TYPE_STANDARD,
+      'is_admin' => FALSE,
+    ];
+
+    $this->roles[$properties['name']] = $this->ogRoleStorage->create($properties);
   }
 
   /**
    * {@inheritdoc}
    */
   public function addRoles(array $roles) {
     foreach ($roles as $role => $properties) {
-      $this->addRole($role, $properties);
+      $this->addRole($properties);
     }
   }
 
   /**
    * {@inheritdoc}
    */
-  public function setRole($name, array $properties) {
-    $this->deleteRole($name);
-    $this->addRole($name, $properties);
+  public function setRole(array $properties) {
+    $this->validate($properties);
+    $this->deleteRole($properties['name']);
+    $this->addRole($properties);
   }
 
   /**
    * {@inheritdoc}
    */
   public function setRoles(array $roles) {
     foreach ($roles as $name => $properties) {
-      $this->setRole($name, $properties);
+      $this->setRole($properties);
     }
   }
 
@@ -106,7 +127,11 @@ public function offsetGet($key) {
    * {@inheritdoc}
    */
   public function offsetSet($key, $value) {
-    $this->setRole($key, $value);
+    $this->validate($value);
+    if ($value['name'] !== $key) {
+      throw new \InvalidArgumentException('The key and the "name" property of the role should be identical.');
+    }
+    $this->setRole($value);
   }
 
   /**
@@ -130,27 +155,36 @@ public function getIterator() {
     return new \ArrayIterator($this->roles);
   }
 
+  /**
+   * {@inheritdoc}
+   */
+  public function reset() {
+    $this->roles = [];
+  }
+
   /**
    * Validates a role that is about to be set or added.
    *
-   * @param string $name
-   *   The name of the role to add or set.
    * @param array $properties
    *   The role properties to validate.
    *
    * @throws \InvalidArgumentException
    *   Thrown when the role name is empty, the 'label' property is missing, or
    *   the 'role_type' property is invalid.
    */
-  protected function validate($name, $properties) {
-    if (empty($name)) {
+  protected function validate($properties) {
+    if (empty($properties['name'])) {
       throw new \InvalidArgumentException('Role name is required.');
     }
 
     if (empty($properties['label'])) {
       throw new \InvalidArgumentException('The label property is required.');
     }
 
+    if (!empty($properties['is_admin']) && !is_bool($properties['is_admin'])) {
+      throw new \InvalidArgumentException('The is_admin property should be a boolean.');
+    }
+
     $valid_role_types = [
       OgRoleInterface::ROLE_TYPE_STANDARD,
       OgRoleInterface::ROLE_TYPE_REQUIRED,

src/Event/DefaultRoleEventInterface.php

@@ -21,6 +21,10 @@ interface DefaultRoleEventInterface extends \ArrayAccess, \IteratorAggregate {
    * @param $name
    *   The name of the role to return.
    *
+   * @return \Drupal\og\Entity\OgRole
+   *   The OgRole entity. Note that we cannot specify OgRoleInterface here
+   *   because of limitations in interface inheritance in PHP 5.
+   *
    * @throws \InvalidArgumentException
    *   Thrown when the role with the given name does not exist.
    */
@@ -37,20 +41,21 @@ public function getRoles();
   /**
    * Adds a default role.
    *
-   * @param string $name
-   *   The name of the role to add.
    * @param array $properties
    *   An associative array of role properties, keyed by the following:
+   *   - 'name': The machine name of the role.
    *   - 'label': The human readable label.
    *   - 'role_type': Either OgRoleInterface::ROLE_TYPE_STANDARD or
    *     OgRoleInterface::ROLE_TYPE_REQUIRED. Defaults to
    *     OgRoleInterface::ROLE_TYPE_STANDARD.
+   *   - 'is_admin': Whether or not the role is an administration role. Defaults
+   *     to FALSE.
    *
    * @throws \InvalidArgumentException
    *   Thrown when the role that is added already exists, when the role name is
    *   empty, or when the 'label' property is missing.
    */
-  public function addRole($name, array $properties);
+  public function addRole(array $properties);
 
   /**
    * Adds multiple default roles.
@@ -63,17 +68,21 @@ public function addRoles(array $roles);
   /**
    * Sets a default roles.
    *
-   * @param string $name
-   *   The name of the role to set.
    * @param array $properties
    *   An associative array of role properties to set, keyed by the following:
+   *   - 'name': The machine name of the role.
    *   - 'label': The human readable label.
+   *   - 'role_type': Either OgRoleInterface::ROLE_TYPE_STANDARD or
+   *     OgRoleInterface::ROLE_TYPE_REQUIRED. Defaults to
+   *     OgRoleInterface::ROLE_TYPE_STANDARD.
+   *   - 'is_admin': Whether or not the role is an administration role. Defaults
+   *     to FALSE.
    *
    * @throws \InvalidArgumentException
    *   Thrown when the role name is empty, or when the 'label' property is
    *   missing.
    */
-  public function setRole($name, array $properties);
+  public function setRole(array $properties);
 
   /**
    * Sets multiple default roles.
@@ -95,11 +104,18 @@ public function deleteRole($name);
    * Returns whether or not the given role exists.
    *
    * @param string $name
-   *   The name of the role for which to verify the existance.
+   *   The name of the role for which to verify the existence.
    *
    * @return bool
    *   TRUE if the role exists, FALSE otherwise.
    */
   public function hasRole($name);
 
+  /**
+   * Resets the internal static cache.
+   *
+   * Call this before dispatching the event.
+   */
+  public function reset();
+
 }

src/EventSubscriber/OgEventSubscriber.php

@@ -69,7 +69,11 @@ public function provideDefaultOgPermissions(PermissionEventInterface $event) {
    *   The default role event.
    */
   public function provideDefaultRoles(DefaultRoleEventInterface $event) {
-    $event->addRole(OgRoleInterface::ADMINISTRATOR, ['label' => 'Administrator']);
+    $event->addRole([
+      'name' => OgRoleInterface::ADMINISTRATOR,
+      'label' => 'Administrator',
+      'is_admin' => TRUE,
+    ]);
   }
 
 }