# user-access-manager/trunk/src/Controller/Backend/Administration/UserGroupController.php

User Access Manager, version trunk. 252 lines.

- Page: https://pluginprobe.com/plugins/user-access-manager/trunk/code/src/Controller/Backend/Administration/UserGroupController.php
- Raw: https://pluginprobe.com/plugins/user-access-manager/trunk/raw/src/Controller/Backend/Administration/UserGroupController.php
- Modified: 2026-08-06T11:11:24+00:00

Line numbers below start at 1. Link to a line or a range by appending a fragment to the
page URL, for example `https://pluginprobe.com/plugins/user-access-manager/trunk/code/src/Controller/Backend/Administration/UserGroupController.php#L10-L20`.

```php
<?php

declare(strict_types=1);

namespace UserAccessManager\Controller\Backend\Administration;

use Exception;
use UserAccessManager\Config\WordpressConfig;
use UserAccessManager\Controller\Backend\ControllerTabNavigationTrait;
use UserAccessManager\Controller\Controller;
use UserAccessManager\Form\FormHelper;
use UserAccessManager\Object\ObjectHandler;
use UserAccessManager\UserGroup\UserGroup;
use UserAccessManager\UserGroup\UserGroupFactory;
use UserAccessManager\UserGroup\UserGroupHandler;
use UserAccessManager\UserGroup\UserGroupTypeException;
use UserAccessManager\Wrapper\Php;
use UserAccessManager\Wrapper\Wordpress;
use WP_Post_Type;
use WP_Taxonomy;

class UserGroupController extends Controller
{
    use ControllerTabNavigationTrait;

    public const INSERT_UPDATE_GROUP_NONCE = 'uamInsertUpdateGroup';
    public const DELETE_GROUP_NONCE = 'uamDeleteGroup';
    public const SET_DEFAULT_USER_GROUPS_NONCE = 'uamSetDefaultUserGroups';
    public const GROUP_USER_GROUPS = 'user_groups';
    public const GROUP_DEFAULT_USER_GROUPS = 'default_user_groups';
    public const DEFAULT_USER_GROUPS_FORM_FIELD = 'default_user_groups';

    protected ?string $template = 'AdminUserGroup.php';
    private ?UserGroup $userGroup = null;

    public function __construct(
        Php $php,
        Wordpress $wordpress,
        WordpressConfig $wordpressConfig,
        private UserGroupHandler $userGroupHandler,
        private UserGroupFactory $userGroupFactory,
        private FormHelper $formHelper
    ) {
        parent::__construct($php, $wordpress, $wordpressConfig);
    }

    public function getTabGroups(): array
    {
        return [
            self::GROUP_USER_GROUPS => ['user_groups'],
            self::GROUP_DEFAULT_USER_GROUPS => array_merge(
                array_keys($this->wordpress->getPostTypes(['public' => true], 'objects')),
                array_keys($this->wordpress->getTaxonomies(['public' => true], 'objects')),
                [ObjectHandler::GENERAL_USER_OBJECT_TYPE]
            )
        ];
    }

    public function getGroupText(string $key, bool $description = false): string
    {
        return $this->formHelper->getText($key, $description);
    }

    public function getGroupSectionText(string $key): string
    {
        $objects = $this->wordpress->getPostTypes(['public' => true], 'objects')
            + $this->wordpress->getTaxonomies(['public' => true], 'objects');

        $objectName = $key;

        if ($objectName === ObjectHandler::GENERAL_USER_OBJECT_TYPE) {
            $objectName = TXT_UAM_USER;
        } elseif (isset($objects[$key]) === true) {
            $objectName = $objects[$key]->labels->name;

            if ($objects[$key] instanceof WP_Post_Type) {
                $objectName .= ' (' . TXT_UAM_POST_TYPE . ')';
            } elseif ($objects[$key] instanceof WP_Taxonomy) {
                $objectName .= ' (' . TXT_UAM_TAXONOMY_TYPE . ')';
            }
        }

        return $objectName;
    }

    /**
     * @throws UserGroupTypeException
     */
    public function getUserGroup(): UserGroup
    {
        if ($this->userGroup === null) {
            $userGroupId = $this->getRequestParameter('userGroupId');
            $this->userGroup = $this->userGroupFactory->createUserGroup($userGroupId);
        }

        return $this->userGroup;
    }

    public function getSortUrl(string $sort): string
    {
        $requestUrl = $this->getRequestUrl();
        $requestUrl = preg_replace('/&amp;orderby[^&]*/i', '', $requestUrl);
        $requestUrl = preg_replace('/&amp;order[^&]*/i', '', $requestUrl);
        $divider = !str_contains($requestUrl, '?') ? '?' : '&amp;';
        $order = (string) $this->getRequestParameter('order') === 'asc' ? 'desc' : 'asc';
        return "$requestUrl{$divider}orderby=$sort&amp;order=$order";
    }

    /**
     * @return UserGroup[]
     * @throws UserGroupTypeException
     */
    public function getUserGroups(): array
    {
        $userGroups = $this->userGroupHandler->getUserGroups();

        $sort = $this->getRequestParameter('orderby');

        if ($sort !== null) {
            $reverse = (string) $this->getRequestParameter('order') === 'desc';

            uasort(
                $userGroups,
                function (UserGroup $userGroupOne, UserGroup $userGroupTwo) use ($sort, $reverse) {
                    $values = ['', ''];
                    $method = 'get' . ucfirst($sort);

                    if (method_exists($userGroupOne, $method) === true) {
                        $values = [(string) $userGroupOne->{$method}(), (string) $userGroupTwo->{$method}()];
                        $values = ($reverse === true) ? array_reverse($values) : $values;
                    }

                    return strnatcasecmp($values[0], $values[1]);
                }
            );
        }

        return $userGroups;
    }

    public function getRoleNames(): array
    {
        $roles = $this->wordpress->getRoles();
        return $roles->role_names;
    }

    /**
     * @throws UserGroupTypeException
     * @throws Exception
     */
    public function insertUpdateUserGroupAction(): void
    {
        $this->verifyNonce(self::INSERT_UPDATE_GROUP_NONCE);

        $userGroupId = $this->getRequestParameter('userGroupId');

        $userGroup = $this->userGroupFactory->createUserGroup($userGroupId);

        $groupName = (string) $this->getRequestParameter('userGroupName');

        if (trim($groupName) === '') {
            $this->setUpdateMessage(TXT_UAM_GROUP_NAME_ERROR);
            return;
        }

        $userGroup->setName($groupName);
        $userGroup->setDescription($this->getRequestParameter('userGroupDescription'));
        $userGroup->setReadAccess($this->getRequestParameter('readAccess'));
        $userGroup->setWriteAccess($this->getRequestParameter('writeAccess'));
        $userGroup->setIpRange($this->getRequestParameter('ipRange'));

        if ($userGroup->save() === false) {
            return;
        }

        $this->assignRolesFromRequest($userGroup);

        $this->setUpdateMessage(
            $userGroupId === null ? TXT_UAM_GROUP_ADDED : TXT_UAM_USER_GROUP_EDIT_SUCCESS
        );

        $this->userGroupHandler->addUserGroup($userGroup);
    }

    private function assignRolesFromRequest(UserGroup $userGroup): void
    {
        $roles = $this->getRequestParameter('roles', []);

        $userGroup->removeObject(ObjectHandler::GENERAL_ROLE_OBJECT_TYPE);

        foreach ($roles as $role) {
            $userGroup->addObject(ObjectHandler::GENERAL_ROLE_OBJECT_TYPE, htmlentities($role));
        }
    }

    /**
     * @throws UserGroupTypeException
     */
    public function deleteUserGroupAction(): void
    {
        $this->verifyNonce(self::DELETE_GROUP_NONCE);
        $userGroups = $this->getRequestParameter('delete', []);

        foreach ($userGroups as $id) {
            $this->userGroupHandler->deleteUserGroup($id);
        }

        $this->setUpdateMessage(TXT_UAM_DELETE_GROUP);
    }

    private function isDefaultTypeAdd(
        array $defaultUserGroups,
        string $userGroupId,
        ?string &$fromTime = null,
        ?string &$toTime = null
    ): bool {
        $userGroupInfo = $defaultUserGroups[$userGroupId] ?? [];

        if (isset($userGroupInfo['id']) === false || (string) $userGroupInfo['id'] !== $userGroupId) {
            return false;
        }

        $fromTime = empty($userGroupInfo['fromTime']) ? null : $userGroupInfo['fromTime'];
        $toTime = empty($userGroupInfo['toTime']) ? null : $userGroupInfo['toTime'];

        return true;
    }

    /**
     * @throws UserGroupTypeException
     * @throws Exception
     */
    public function setDefaultUserGroupsAction(): void
    {
        $this->verifyNonce(self::SET_DEFAULT_USER_GROUPS_NONCE);
        $objectType = $this->getCurrentTabGroupSection();
        $defaultUserGroups = $this->getRequestParameter(self::DEFAULT_USER_GROUPS_FORM_FIELD, []);
        $userGroups = $this->getUserGroups();

        foreach ($userGroups as $userGroup) {
            $userGroupId = $userGroup->getId();
            $userGroup->removeDefaultType($objectType);

            if ($this->isDefaultTypeAdd($defaultUserGroups, $userGroupId, $fromTime, $toTime) === true) {
                $userGroup->addDefaultType($objectType, $fromTime, $toTime);
            }
        }

        $this->setUpdateMessage(TXT_UAM_SET_DEFAULT_USER_GROUP_SUCCESS);
    }
}

```