| @@ -1,56 +1,120 @@ | ||
| 1 | 1 | <?php |
| 2 | - | |
| 3 | -declare(strict_types=1); | |
| 4 | - | |
| 2 | +/** | |
| 3 | + * UserGroupHandler.php | |
| 4 | + * | |
| 5 | + * The UserGroupHandler class file. | |
| 6 | + * | |
| 7 | + * PHP versions 5 | |
| 8 | + * | |
| 9 | + * @author Alexander Schneider <[email protected]> | |
| 10 | + * @copyright 2008-2017 Alexander Schneider | |
| 11 | + * @license http://www.gnu.org/licenses/gpl-2.0.html GNU General Public License, version 2 | |
| 12 | + * @version SVN: $id$ | |
| 13 | + * @link http://wordpress.org/extend/plugins/user-access-manager/ | |
| 14 | + */ | |
| 5 | 15 | namespace UserAccessManager\UserGroup; |
| 6 | 16 | |
| 7 | -use Exception; | |
| 8 | -use UserAccessManager\Config\MainConfig; | |
| 9 | 17 | use UserAccessManager\Config\WordpressConfig; |
| 10 | 18 | use UserAccessManager\Database\Database; |
| 11 | 19 | use UserAccessManager\Object\ObjectHandler; |
| 12 | 20 | use UserAccessManager\User\UserHandler; |
| 13 | 21 | use UserAccessManager\Wrapper\Wordpress; |
| 14 | -use WP_User; | |
| 15 | 22 | |
| 23 | +/** | |
| 24 | + * Class UserGroupHandler | |
| 25 | + * | |
| 26 | + * @package UserAccessManager\UserGroup | |
| 27 | + */ | |
| 16 | 28 | class UserGroupHandler |
| 17 | 29 | { |
| 18 | - /** @var null|UserGroup[] */ | |
| 19 | - private ?array $userGroups = null; | |
| 20 | - /** @var null|DynamicUserGroup[] */ | |
| 21 | - private ?array $dynamicUserGroups = null; | |
| 22 | - /** @var null|AbstractUserGroup[] */ | |
| 23 | - private ?array $userGroupsForUser = null; | |
| 24 | - /** @var AbstractUserGroup[] */ | |
| 25 | - private array $objectUserGroups = []; | |
| 30 | + /** | |
| 31 | + * @var Wordpress | |
| 32 | + */ | |
| 33 | + private $wordpress; | |
| 26 | 34 | |
| 35 | + /** | |
| 36 | + * @var WordpressConfig | |
| 37 | + */ | |
| 38 | + private $wordpressConfig; | |
| 39 | + | |
| 40 | + /** | |
| 41 | + * @var Database | |
| 42 | + */ | |
| 43 | + private $database; | |
| 44 | + | |
| 45 | + /** | |
| 46 | + * @var ObjectHandler | |
| 47 | + */ | |
| 48 | + private $objectHandler; | |
| 49 | + | |
| 50 | + /** | |
| 51 | + * @var UserHandler | |
| 52 | + */ | |
| 53 | + private $userHandler; | |
| 54 | + | |
| 55 | + /** | |
| 56 | + * @var UserGroupFactory | |
| 57 | + */ | |
| 58 | + private $userGroupFactory; | |
| 59 | + | |
| 60 | + /** | |
| 61 | + * @var null|UserGroup[] | |
| 62 | + */ | |
| 63 | + private $userGroups = null; | |
| 64 | + | |
| 65 | + /** | |
| 66 | + * @var null|DynamicUserGroup[] | |
| 67 | + */ | |
| 68 | + private $dynamicUserGroups = null; | |
| 69 | + | |
| 70 | + /** | |
| 71 | + * @var null|UserGroup[] | |
| 72 | + */ | |
| 73 | + private $filteredUserGroups = null; | |
| 74 | + | |
| 75 | + /** | |
| 76 | + * @var null|AbstractUserGroup[] | |
| 77 | + */ | |
| 78 | + private $userGroupsForUser = null; | |
| 79 | + | |
| 80 | + /** | |
| 81 | + * @var array | |
| 82 | + */ | |
| 83 | + private $objectUserGroups = []; | |
| 84 | + | |
| 27 | 85 | public function __construct( |
| 28 | - private Wordpress $wordpress, | |
| 29 | - private WordpressConfig $wordpressConfig, | |
| 30 | - private MainConfig $mainConfig, | |
| 31 | - private Database $database, | |
| 32 | - private ObjectHandler $objectHandler, | |
| 33 | - private UserHandler $userHandler, | |
| 34 | - private UserGroupFactory $userGroupFactory | |
| 86 | + Wordpress $wordpress, | |
| 87 | + WordpressConfig $wordpressConfig, | |
| 88 | + Database $database, | |
| 89 | + ObjectHandler $objectHandler, | |
| 90 | + UserHandler $userHandler, | |
| 91 | + UserGroupFactory $userGroupFactory | |
| 35 | 92 | ) { |
| 93 | + $this->wordpress = $wordpress; | |
| 94 | + $this->wordpressConfig = $wordpressConfig; | |
| 95 | + $this->database = $database; | |
| 96 | + $this->objectHandler = $objectHandler; | |
| 97 | + $this->userHandler = $userHandler; | |
| 98 | + $this->userGroupFactory = $userGroupFactory; | |
| 36 | 99 | } |
| 37 | 100 | |
| 38 | 101 | /** |
| 39 | - * @return null|UserGroup[] | |
| 40 | - * @throws UserGroupTypeException | |
| 102 | + * Returns all user groups. | |
| 103 | + * | |
| 104 | + * @return UserGroup[] | |
| 41 | 105 | */ |
| 42 | - public function getUserGroups(): ?array | |
| 106 | + public function getUserGroups() | |
| 43 | 107 | { |
| 44 | 108 | if ($this->userGroups === null) { |
| 45 | 109 | $this->userGroups = []; |
| 46 | 110 | |
| 47 | - $query = "SELECT * FROM {$this->database->getUserGroupTable()}"; | |
| 48 | - $databaseUserGroups = (array) $this->database->getResults($query); | |
| 111 | + $query = "SELECT ID FROM {$this->database->getUserGroupTable()}"; | |
| 112 | + $userGroups = (array)$this->database->getResults($query); | |
| 49 | 113 | |
| 50 | - foreach ($databaseUserGroups as $databaseUserGroup) { | |
| 51 | - $userGroup = $this->userGroupFactory->createUserGroupFromDatabaseRow($databaseUserGroup); | |
| 52 | - $this->userGroups[$userGroup->getId()] = $userGroup; | |
| 114 | + foreach ($userGroups as $userGroup) { | |
| 115 | + $group = $this->userGroupFactory->createUserGroup($userGroup->ID); | |
| 116 | + $this->userGroups[$group->getId()] = $group; | |
| 53 | 117 | } |
| 54 | 118 | } |
| 55 | 119 | |
| 56 | 120 | return $this->userGroups; |
| @@ -56,12 +120,13 @@ | ||
| 56 | 120 | return $this->userGroups; |
| 57 | 121 | } |
| 58 | 122 | |
| 59 | 123 | /** |
| 124 | + * Returns all dynamic user groups. | |
| 125 | + * | |
| 60 | 126 | * @return null|DynamicUserGroup[] |
| 61 | - * @throws UserGroupTypeException | |
| 62 | 127 | */ |
| 63 | - public function getDynamicUserGroups(): ?array | |
| 128 | + public function getDynamicUserGroups() | |
| 64 | 129 | { |
| 65 | 130 | if ($this->dynamicUserGroups === null) { |
| 66 | 131 | $this->dynamicUserGroups = []; |
| 67 | 132 | |
| @@ -74,12 +139,12 @@ | ||
| 74 | 139 | $userGroupTypes = implode('\', \'', [DynamicUserGroup::ROLE_TYPE, DynamicUserGroup::USER_TYPE]); |
| 75 | 140 | |
| 76 | 141 | $query = "SELECT group_id AS id, group_type AS type |
| 77 | 142 | FROM {$this->database->getUserGroupToObjectTable()} |
| 78 | - WHERE group_type IN ('$userGroupTypes') | |
| 143 | + WHERE group_type IN ('{$userGroupTypes}') | |
| 79 | 144 | GROUP BY group_type, group_id"; |
| 80 | 145 | |
| 81 | - $dynamicUserGroups = (array) $this->database->getResults($query); | |
| 146 | + $dynamicUserGroups = (array)$this->database->getResults($query); | |
| 82 | 147 | |
| 83 | 148 | foreach ($dynamicUserGroups as $dynamicUserGroup) { |
| 84 | 149 | $group = $this->userGroupFactory->createDynamicUserGroup( |
| 85 | 150 | $dynamicUserGroup->type, |
| @@ -93,21 +158,23 @@ | ||
| 93 | 158 | return $this->dynamicUserGroups; |
| 94 | 159 | } |
| 95 | 160 | |
| 96 | 161 | /** |
| 97 | - * @return null|AbstractUserGroup[] | |
| 98 | - * @throws UserGroupTypeException | |
| 162 | + * Returns the full user groups | |
| 163 | + * | |
| 164 | + * @return AbstractUserGroup[] | |
| 99 | 165 | */ |
| 100 | - public function getFullUserGroups(): ?array | |
| 166 | + public function getFullUserGroups() | |
| 101 | 167 | { |
| 102 | 168 | return $this->getUserGroups() + $this->getDynamicUserGroups(); |
| 103 | 169 | } |
| 104 | 170 | |
| 105 | 171 | /** |
| 172 | + * Returns the user groups filtered by the user user groups. | |
| 173 | + * | |
| 106 | 174 | * @return AbstractUserGroup[] |
| 107 | - * @throws UserGroupTypeException | |
| 108 | 175 | */ |
| 109 | - public function getFilteredUserGroups(): array | |
| 176 | + public function getFilteredUserGroups() | |
| 110 | 177 | { |
| 111 | 178 | $userGroups = $this->getFullUserGroups(); |
| 112 | 179 | $userUserGroups = $this->getUserGroupsForUser() + $this->getDynamicUserGroups(); |
| 113 | 180 | return array_intersect_key($userGroups, $userUserGroups); |
| @@ -113,21 +180,27 @@ | ||
| 113 | 180 | return array_intersect_key($userGroups, $userUserGroups); |
| 114 | 181 | } |
| 115 | 182 | |
| 116 | 183 | /** |
| 117 | - * @throws UserGroupTypeException | |
| 184 | + * Adds a user group. | |
| 185 | + * | |
| 186 | + * @param UserGroup $userGroup | |
| 118 | 187 | */ |
| 119 | - public function addUserGroup(UserGroup $userGroup): void | |
| 188 | + public function addUserGroup(UserGroup $userGroup) | |
| 120 | 189 | { |
| 121 | 190 | $this->getUserGroups(); |
| 122 | 191 | $this->userGroups[$userGroup->getId()] = $userGroup; |
| 192 | + $this->filteredUserGroups = null; | |
| 123 | 193 | } |
| 124 | 194 | |
| 125 | 195 | /** |
| 126 | - * @throws UserGroupTypeException | |
| 127 | - * @throws Exception | |
| 196 | + * Deletes a user group. | |
| 197 | + * | |
| 198 | + * @param int $userGroupId | |
| 199 | + * | |
| 200 | + * @return bool | |
| 128 | 201 | */ |
| 129 | - public function deleteUserGroup(int|string $userGroupId): bool | |
| 202 | + public function deleteUserGroup($userGroupId) | |
| 130 | 203 | { |
| 131 | 204 | $userGroups = $this->getUserGroups(); |
| 132 | 205 | |
| 133 | 206 | if (isset($userGroups[$userGroupId]) |
| @@ -133,8 +206,9 @@ | ||
| 133 | 206 | if (isset($userGroups[$userGroupId]) |
| 134 | 207 | && $userGroups[$userGroupId]->delete() === true |
| 135 | 208 | ) { |
| 136 | 209 | unset($this->userGroups[$userGroupId]); |
| 210 | + $this->filteredUserGroups = null; | |
| 137 | 211 | |
| 138 | 212 | return true; |
| 139 | 213 | } |
| 140 | 214 | |
| @@ -141,22 +215,23 @@ | ||
| 141 | 215 | return false; |
| 142 | 216 | } |
| 143 | 217 | |
| 144 | 218 | /** |
| 219 | + * Returns the user groups for the given object. | |
| 220 | + * | |
| 221 | + * @param string $objectType The object type. | |
| 222 | + * @param integer $objectId The id of the object. | |
| 223 | + * @param bool $ignoreDates If true we ignore the dates for the object assignment. | |
| 224 | + * | |
| 145 | 225 | * @return AbstractUserGroup[] |
| 146 | - * @throws UserGroupTypeException | |
| 147 | - * @throws Exception | |
| 148 | 226 | */ |
| 149 | - public function getUserGroupsForObject( | |
| 150 | - string $objectType, | |
| 151 | - int|string|null $objectId, | |
| 152 | - bool $ignoreDates = false | |
| 153 | - ): array { | |
| 227 | + public function getUserGroupsForObject($objectType, $objectId, $ignoreDates = false) | |
| 228 | + { | |
| 154 | 229 | if ($this->objectHandler->isValidObjectType($objectType) === false) { |
| 155 | 230 | return []; |
| 156 | 231 | } |
| 157 | 232 | |
| 158 | - if (isset($this->objectUserGroups[$ignoreDates][$objectType][$objectId]) === false) { | |
| 233 | + if (isset($this->objectUserGroups[(int)$ignoreDates][$objectType][$objectId]) === false) { | |
| 159 | 234 | $objectUserGroups = []; |
| 160 | 235 | $userGroups = $this->getFullUserGroups(); |
| 161 | 236 | |
| 162 | 237 | foreach ($userGroups as $userGroup) { |
| @@ -166,25 +241,32 @@ | ||
| 166 | 241 | $objectUserGroups[$userGroup->getId()] = $userGroup; |
| 167 | 242 | } |
| 168 | 243 | } |
| 169 | 244 | |
| 170 | - $this->objectUserGroups[$ignoreDates][$objectType][$objectId] = $objectUserGroups; | |
| 245 | + $this->objectUserGroups[(int)$ignoreDates][$objectType][$objectId] = $objectUserGroups; | |
| 171 | 246 | } |
| 172 | 247 | |
| 173 | - return $this->objectUserGroups[$ignoreDates][$objectType][$objectId]; | |
| 248 | + return $this->objectUserGroups[(int)$ignoreDates][$objectType][$objectId]; | |
| 174 | 249 | } |
| 175 | 250 | |
| 176 | - public function unsetUserGroupsForObject(): void | |
| 251 | + /** | |
| 252 | + * Unset the object user groups. | |
| 253 | + */ | |
| 254 | + public function unsetUserGroupsForObject() | |
| 177 | 255 | { |
| 178 | 256 | $this->objectUserGroups = []; |
| 179 | 257 | } |
| 180 | 258 | |
| 181 | - private function checkUserGroupAccess(UserGroup $userGroup): bool | |
| 259 | + /** | |
| 260 | + * Checks if the current user is in the ip range or if the user group is public. | |
| 261 | + * | |
| 262 | + * @param UserGroup $userGroup | |
| 263 | + * | |
| 264 | + * @return bool | |
| 265 | + */ | |
| 266 | + private function checkUserGroupAccess(UserGroup $userGroup) | |
| 182 | 267 | { |
| 183 | - $extraIpHeader = $this->mainConfig->getExtraIpHeader(); | |
| 184 | - $userIp = $extraIpHeader !== null ? | |
| 185 | - $_SERVER[$extraIpHeader] ?? ($_SERVER['REMOTE_ADDR'] ?? '') : | |
| 186 | - $_SERVER['REMOTE_ADDR'] ?? ''; | |
| 268 | + $userIp = isset($_SERVER['HTTP_X_REAL_IP']) ? $_SERVER['HTTP_X_REAL_IP'] : $_SERVER['REMOTE_ADDR']; | |
| 187 | 269 | |
| 188 | 270 | return $this->userHandler->isIpInRange($userIp, $userGroup->getIpRangeArray()) |
| 189 | 271 | || $this->wordpressConfig->atAdminPanel() === false && $userGroup->getReadAccess() === 'all' |
| 190 | 272 | || $this->wordpressConfig->atAdminPanel() === true && $userGroup->getWriteAccess() === 'all'; |
| @@ -190,11 +272,14 @@ | ||
| 190 | 272 | || $this->wordpressConfig->atAdminPanel() === true && $userGroup->getWriteAccess() === 'all'; |
| 191 | 273 | } |
| 192 | 274 | |
| 193 | 275 | /** |
| 194 | - * @throws UserGroupTypeException | |
| 276 | + * Assigns the dynamic user groups to the user user groups. | |
| 277 | + * | |
| 278 | + * @param \WP_User $currentUser | |
| 279 | + * @param array $userGroupsForUser | |
| 195 | 280 | */ |
| 196 | - private function assignDynamicUserGroupsForUser(WP_User $currentUser, array &$userGroupsForUser): void | |
| 281 | + private function assignDynamicUserGroupsForUser(\WP_User $currentUser, array &$userGroupsForUser) | |
| 197 | 282 | { |
| 198 | 283 | $userUserGroup = $this->userGroupFactory->createDynamicUserGroup( |
| 199 | 284 | DynamicUserGroup::USER_TYPE, |
| 200 | 285 | $currentUser->ID |
| @@ -212,12 +297,13 @@ | ||
| 212 | 297 | } |
| 213 | 298 | } |
| 214 | 299 | |
| 215 | 300 | /** |
| 216 | - * @return AbstractUserGroup[]|null | |
| 217 | - * @throws UserGroupTypeException | |
| 301 | + * Returns the user groups for the user. | |
| 302 | + * | |
| 303 | + * @return AbstractUserGroup[] | |
| 218 | 304 | */ |
| 219 | - public function getUserGroupsForUser(): ?array | |
| 305 | + public function getUserGroupsForUser() | |
| 220 | 306 | { |
| 221 | 307 | if ($this->userHandler->checkUserAccess(UserHandler::MANAGE_USER_GROUPS_CAPABILITY) === true) { |
| 222 | 308 | return $this->getUserGroups(); |
| 223 | 309 | } |
| @@ -246,16 +332,18 @@ | ||
| 246 | 332 | return $this->userGroupsForUser; |
| 247 | 333 | } |
| 248 | 334 | |
| 249 | 335 | /** |
| 336 | + * Returns the user groups for the object filtered by the user user groups. | |
| 337 | + * | |
| 338 | + * @param string $objectType | |
| 339 | + * @param int $objectId | |
| 340 | + * @param bool $ignoreDates | |
| 341 | + * | |
| 250 | 342 | * @return AbstractUserGroup[] |
| 251 | - * @throws UserGroupTypeException | |
| 252 | 343 | */ |
| 253 | - public function getFilteredUserGroupsForObject( | |
| 254 | - string $objectType, | |
| 255 | - int|string|null $objectId, | |
| 256 | - bool $ignoreDates = false | |
| 257 | - ): array { | |
| 344 | + public function getFilteredUserGroupsForObject($objectType, $objectId, $ignoreDates = false) | |
| 345 | + { | |
| 258 | 346 | $userGroups = $this->getUserGroupsForObject($objectType, $objectId, $ignoreDates); |
| 259 | 347 | $userUserGroups = $this->getUserGroupsForUser() + $this->getDynamicUserGroups(); |
| 260 | 348 | return array_intersect_key($userGroups, $userUserGroups); |
| 261 | 349 | } |
