Subscribe and unsubscribe routes

og_ui/og_ui.routing.yml

@@ -16,6 +16,23 @@ og_ui.settings:
   requirements:
     _permission: 'administer group'
 
+og_ui.subscribe:
+  path: 'group/{entity_type_id}/{entity_id}/subscribe/{field_name}'
+  defaults:
+    _controller: '\Drupal\og_ui\Controller\SubscriptionController::subscribe'
+    _title: 'Join Group'
+    field_name: null
+  requirements:
+    _user_is_logged_in: 'TRUE'
+
+og_ui.unsubscribe:
+  path: 'group/{entity_type_id}/{entity_id}/unsubscribe'
+  defaults:
+    _controller: '\Drupal\og_ui\Controller\SubscriptionController::unsubscribe'
+    _title: 'Leave Group'
+  requirements:
+    _og_ui_user_access_group: 'unsubscribe'
+
 og_ui.roles_permissions_overview:
   path: 'admin/config/group/{type}'
   defaults:

og_ui/og_ui.services.yml

@@ -1,4 +1,10 @@
 services:
+  access_check.og.user_access_group:
+    class: Drupal\og_ui\Access\GroupCheck
+    arguments: ['@entity_type.manager']
+    tags:
+      - { name: access_check, applies_to: _og_ui_user_access_group }
+
   og_ui.event_subscriber:
     class: Drupal\og_ui\EventSubscriber\OgUiEventSubscriber
     tags:

og_ui/src/Access/GroupCheck.php

@@ -0,0 +1,76 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\og_ui\Access\GroupCheck.
+ */
+
+namespace Drupal\og_ui\Access;
+
+use Drupal\Core\Access\AccessResult;
+use Drupal\Core\Entity\EntityTypeManagerInterface;
+use Drupal\Core\Routing\Access\AccessInterface;
+use Drupal\Core\Session\AccountInterface;
+use Drupal\og\Og;
+use Drupal\og\OgAccess;
+use Symfony\Component\Routing\Route;
+
+/**
+ * Determines access to routes based on group access for the current user.
+ */
+class GroupCheck implements AccessInterface {
+
+  /**
+   * The entity type manager service.
+   *
+   * @var \Drupal\Core\Entity\EntityTypeManagerInterface
+   */
+  protected $entityTypeManager;
+
+  /**
+   * Constructs a GroupCheck object.
+   *
+   * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
+   */
+  public function __construct(EntityTypeManagerInterface $entity_type_manager) {
+    $this->entityTypeManager = $entity_type_manager;
+  }
+
+  /**
+   * Checks access.
+   *
+   * @param \Drupal\Core\Session\AccountInterface $account
+   *   The currently logged in account.
+   * @param \Symfony\Component\Routing\Route $route
+   *   The route to check against.
+   *
+   * @return \Drupal\Core\Access\AccessResultInterface
+   *   The access result.
+   */
+  public function access(AccountInterface $account, Route $route, $entity_type_id, $entity_id) {
+    // No access if the entity type doesn't exist.
+    if (!$this->entityTypeManager->getDefinition($entity_type_id, FALSE)) {
+      return AccessResult::forbidden();
+    }
+
+    $entity_storage = $this->entityTypeManager->getStorage($entity_type_id);
+    $group = $entity_storage->load($entity_id);
+
+    // No access if no entity was loaded or it's not a group.
+    if (!$group || !Og::isGroup($entity_type_id, $group->bundle())) {
+      return AccessResult::forbidden();
+    }
+
+    // @todo Convert when Role checking is added and has API to use.
+    // Verify the bundle has roles
+//    if (!og_roles($group_type, $bundle, $gid)) {
+//      return AccessResult::forbidden();
+//    }
+
+    $permission = $permission = $route->getRequirement('_og_ui_user_access_group');
+
+    return OgAccess::userAccess($group, $permission);
+  }
+
+}
+

og_ui/src/Controller/SubscriptionController.php

@@ -0,0 +1,164 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\og_ui\Controller\SubscriptionController.
+ */
+
+namespace Drupal\og_ui\Controller;
+
+use Drupal\Core\Controller\ControllerBase;
+use Drupal\Core\Field\FieldStorageDefinitionInterface;
+use Drupal\Core\Url;
+use Drupal\og\OgMembershipInterface;
+use Drupal\user\Entity\User;
+use Drupal\user\EntityOwnerInterface;
+use Symfony\Component\HttpFoundation\RedirectResponse;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
+use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
+use Drupal\og\Og;
+use Drupal\og\OgAccess;
+
+/**
+ * Controller for OG subscription routes.
+ */
+class SubscriptionController extends ControllerBase {
+
+  /**
+   * @param string $entity_type_id
+   * @param string|int $entity_id
+   * @param NULL|string $field_name
+   *
+   * @return mixed
+   */
+  public function subscribe(Request $request, $entity_type_id, $entity_id, $field_name) {
+    // @todo We don't need to re-validate the entity type and entity group here,
+    // as it's already been done in the access check?
+    $entity_storage = $this->entityTypeManager()->getStorage($entity_type_id);
+    $entity_access = $this->entityTypeManager()->getAccessControlHandler($entity_type_id);
+    $group = $entity_storage->load($entity_id);
+
+    $account = User::load($this->currentUser()->id());
+
+    if (empty($field_name)) {
+      $field_name = og_get_best_group_audience_field('user', $account, $entity_type_id, $group->bundle());
+      if (empty($field_name)) {
+        throw new NotFoundHttpException();
+      }
+    }
+
+    // @todo Requires FieldableEntityInterface/ContentEntityInterface
+    $field = $group->getFieldDefinition($field_name);
+
+    if (empty($instance) || !$entity_access->fieldAccess('view', $field, $account)) {
+      // Field name given is incorrect, or user doesn't have access to the field.
+      throw new NotFoundHttpException();
+    }
+
+    if ($account->isAnonymous()) {
+      // Anonymous user can't request membership.
+      $destination = $this->getDestinationArray();
+
+      $user_login_url = Url::fromRoute('user.login', [], $destination)->toString();
+
+      // @todo I think this is correct? Other options are visitors or require
+      // approval both of which apply to the else instead of here.
+      if ($this->config('user.settings')->get('register') === USER_REGISTER_ADMINISTRATORS_ONLY) {
+        drupal_set_message($this->t('In order to join any group, you must <a href=":login">login</a>. After you have successfully done so, you will need to request membership again.', [':login' => $user_login_url]));
+      }
+      else {
+        $user_register_url = Url::fromRoute('user.register', [], $destination)->toString();
+        drupal_set_message($this->t('In order to join any group, you must <a href=":login">login</a> or <a href=":register">register</a> a new account. After you have successfully done so, you will need to request membership again.', [':register' => $user_register_url, ':login' => $user_login_url]));
+      }
+
+      return new RedirectResponse(Url::fromRoute('user.page')->setAbsolute(TRUE)->toString());
+    }
+
+    $redirect = FALSE;
+    $message = '';
+    $params = [
+      '@user' => $account->getDisplayName(),
+    ];
+
+    // Show the group name only if user has access to it.
+    $params['@group'] = $group->access('view', $account) ?  $group->label() : $this->t('Private group');
+
+    if (Og::isMemberBlocked($group, $account)) {
+      // User is blocked, access denied.
+      throw new AccessDeniedHttpException();
+    }
+
+    if (Og::isMemberPending($group, $account)) {
+      // User is pending, return them back.
+      $message = $this->t('@user already has a pending membership for the  the group @group.', $params);
+      $redirect = TRUE;
+    }
+
+    if (Og::isMember($group, $account)) {
+      // User is already a member, return them back.
+      $message = $this->t('You are already a member of the group @group.', $params);
+      $redirect = TRUE;
+    }
+
+    $cardinality = $field->getStorageDefinition()->getCardinality();
+
+    if (!$message && ($cardinality != FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED)) {
+      // Check if user is already registered as active or pending in the maximum
+      // allowed values.
+      if ($cardinality === 1) {
+        $count = $account->get($field_name)->value ? 1 : 0;
+      }
+      else {
+        $count = $account->get($field_name)->count();
+      }
+
+      if ($count >= $cardinality) {
+        $message = $this->t('You cannot register to this group, as you have reached your maximum allowed subscriptions.');
+        $redirect = TRUE;
+      }
+    }
+
+    if ($redirect) {
+      drupal_set_message($message, 'warning');
+      return new RedirectResponse($group->toUrl()->setAbsolute(TRUE)->toString());
+    }
+
+    if (OgAccess::userAccess($group, 'subscribe', $account) || OgAccess::userAccess($group, 'subscribe without approval', $account)) {
+      // Show the user a subscription confirmation.
+      // @todo Use buildForm() create our own form state object and attach
+      // field_name etc..?
+      return $this->formBuilder()->getForm('\Drupal\og_ui\Form\GroupSubscribeConfirmForm', $group, $account, $field_name);
+    }
+
+    throw new AccessDeniedHttpException();
+  }
+
+  /**
+   * @param string $entity_type_id
+   * @param string|int $entity_id
+   */
+  public function unsubscribe($entity_type_id, $entity_id) {
+    // @todo We don't need to re-validate the entity type and entity group here,
+    // as it's already been done in the access check?
+    $entity_storage = $this->entityTypeManager()->getStorage($entity_type_id);
+    $group = $entity_storage->load($entity_id);
+
+    $account = $this->currentUser();
+
+    // Check the user isn't the manager of the group.
+    if (($group instanceof EntityOwnerInterface) && ($group->getOwnerId() !== $account->id())) {
+      if (Og::isMember($group, $account, [OgMembershipInterface::STATE_ACTIVE, OgMembershipInterface::STATE_PENDING])) {
+        // Show the user a subscription confirmation.
+        return $this->formBuilder()->getForm('\Drupal\og_ui\Form\GroupUnsubscribeConfirmForm', $group);
+      }
+
+      throw new AccessDeniedHttpException();
+    }
+
+    drupal_set_message(t('As the manager of %group, you can not leave the group.', array('%group' => $group->label())));
+
+    return new RedirectResponse($group->toUrl()->setAbsolute(TRUE)->toString());
+  }
+
+}

og_ui/src/Form/GroupSubscribeConfirmForm.php

@@ -0,0 +1,116 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\og_ui\Form\GroupSubscribeConfirmForm.
+ */
+
+namespace Drupal\og_ui\Form;
+
+use Drupal\Core\Entity\EntityConfirmFormBase;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\og\OgAccess;
+use Drupal\og\OgMembershipInterface;
+
+/**
+ * Provides a confirmation form for subscribing form a group.
+ */
+class GroupSubscribeConfirmForm extends EntityConfirmFormBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getFormId() {
+    return 'og_ui_subscribe_confirm_form';
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getQuestion() {
+    return $this->t('Are you sure you want to join the group %title?', ['%title' => $this->entity->label()]);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getConfirmText() {
+    return $this->t('Join');
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getCancelUrl() {
+    // TODO: Implement getCancelUrl() method.
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function buildForm(array $form, FormStateInterface $form_state) {
+    // Indicate the OG membership state (active or pending).
+    $state = OgAccess::userAccess($this->entity, 'subscribe without approval') ? OgMembershipInterface::STATE_ACTIVE : OgMembershipInterface::STATE_PENDING;
+
+    if ($this->entity->access('view')) {
+      $label = $this->entity->label();
+    }
+    else {
+      $label = $this->t('Private group');
+
+      if ($state === OgMembershipInterface::STATE_ACTIVE) {
+        // Determine if a user can subscribe to a private group, when OG-access
+        // module is enabled, and the group is set to private.
+        $state = $this->config('og_ui.settings')->get('deny_subscribe_without_approval') ? OgMembershipInterface::STATE_PENDING : OgMembershipInterface::STATE_ACTIVE;
+      }
+    }
+
+//    // Add group membership form.
+//    $og_membership = og_membership_create($group_type, $gid, 'user', $account->uid, $field_name, array('state' => $state));
+//    $form_state['og_membership'] = $og_membership;
+//    field_attach_form('og_membership', $og_membership, $form, $form_state);
+//
+//    if ($state == OG_STATE_ACTIVE && !empty($form[OG_MEMBERSHIP_REQUEST_FIELD])) {
+//      // Hide the user request field.
+//      $form[OG_MEMBERSHIP_REQUEST_FIELD]['#access'] = FALSE;
+//    }
+//    $form['group_type'] = array('#type' => 'value', '#value' => $group_type);
+//    $form['gid'] = array('#type' => 'value', '#value' => $gid);
+//    $form['field_name'] = array('#type' => 'value', '#value' => $field_name);
+
+    return parent::buildForm($form, $form_state);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function validateForm(array &$form, FormStateInterface $form_state) {
+    parent::validateForm($form, $form_state);
+
+    // @see entity_form_field_validate().
+    $og_membership = $form_state['og_membership'];
+    field_attach_form_validate('og_membership', $og_membership, $form, $form_state);
+  }
+
+
+  /**
+   * {@inheritdoc}
+   */
+  public function submitForm(array &$form, FormStateInterface $form_state) {
+    $og_membership = $form_state['og_membership'];
+    field_attach_submit('og_membership', $og_membership, $form, $form_state);
+
+    $og_membership->save();
+
+    if ($this->entity->access('view')) {
+      $form_state->setRedirectUrl($this->entity->toUrl());
+    }
+    else {
+      // User doesn't have access to the group entity, so redirect to front page,
+      // with a message.
+      drupal_set_message($this->t('Your subscription request was sent.'));
+    }
+  }
+
+}
+