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