ezsystems /
ezpublish-kernel
Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.
Common duplication problems, and corresponding solutions are:
Complex classes like UserService often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use UserService, and based on these observations, apply Extract Interface, too.
| 1 | <?php |
||
| 47 | class UserService implements UserServiceInterface |
||
| 48 | { |
||
| 49 | /** |
||
| 50 | * @var \eZ\Publish\API\Repository\Repository |
||
| 51 | */ |
||
| 52 | protected $repository; |
||
| 53 | |||
| 54 | /** |
||
| 55 | * @var \eZ\Publish\SPI\Persistence\User\Handler |
||
| 56 | */ |
||
| 57 | protected $userHandler; |
||
| 58 | |||
| 59 | /** |
||
| 60 | * @var array |
||
| 61 | */ |
||
| 62 | protected $settings; |
||
| 63 | |||
| 64 | /** |
||
| 65 | * Setups service with reference to repository object that created it & corresponding handler. |
||
| 66 | * |
||
| 67 | * @param \eZ\Publish\API\Repository\Repository $repository |
||
| 68 | * @param \eZ\Publish\SPI\Persistence\User\Handler $userHandler |
||
| 69 | * @param array $settings |
||
| 70 | */ |
||
| 71 | public function __construct(RepositoryInterface $repository, Handler $userHandler, array $settings = array()) |
||
| 72 | { |
||
| 73 | $this->repository = $repository; |
||
| 74 | $this->userHandler = $userHandler; |
||
| 75 | // Union makes sure default settings are ignored if provided in argument |
||
| 76 | $this->settings = $settings + array( |
||
| 77 | 'defaultUserPlacement' => 12, |
||
| 78 | 'userClassID' => 4, // @todo Rename this settings to swap out "Class" for "Type" |
||
| 79 | 'userGroupClassID' => 3, |
||
| 80 | 'hashType' => User::PASSWORD_HASH_MD5_USER, |
||
| 81 | 'siteName' => 'ez.no', |
||
| 82 | ); |
||
| 83 | } |
||
| 84 | |||
| 85 | /** |
||
| 86 | * Creates a new user group using the data provided in the ContentCreateStruct parameter. |
||
| 87 | * |
||
| 88 | * In 4.x in the content type parameter in the profile is ignored |
||
| 89 | * - the content type is determined via configuration and can be set to null. |
||
| 90 | * The returned version is published. |
||
| 91 | * |
||
| 92 | * @param \eZ\Publish\API\Repository\Values\User\UserGroupCreateStruct $userGroupCreateStruct a structure for setting all necessary data to create this user group |
||
| 93 | * @param \eZ\Publish\API\Repository\Values\User\UserGroup $parentGroup |
||
| 94 | * |
||
| 95 | * @return \eZ\Publish\API\Repository\Values\User\UserGroup |
||
| 96 | * |
||
| 97 | * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the authenticated user is not allowed to create a user group |
||
| 98 | * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException if the input structure has invalid data |
||
| 99 | * @throws \eZ\Publish\API\Repository\Exceptions\ContentFieldValidationException if a field in the $userGroupCreateStruct is not valid |
||
| 100 | * @throws \eZ\Publish\API\Repository\Exceptions\ContentValidationException if a required field is missing or set to an empty value |
||
| 101 | */ |
||
| 102 | public function createUserGroup(APIUserGroupCreateStruct $userGroupCreateStruct, APIUserGroup $parentGroup) |
||
| 103 | { |
||
| 104 | $contentService = $this->repository->getContentService(); |
||
| 105 | $locationService = $this->repository->getLocationService(); |
||
| 106 | $contentTypeService = $this->repository->getContentTypeService(); |
||
| 107 | |||
| 108 | if ($userGroupCreateStruct->contentType === null) { |
||
| 109 | $userGroupContentType = $contentTypeService->loadContentType($this->settings['userGroupClassID']); |
||
| 110 | $userGroupCreateStruct->contentType = $userGroupContentType; |
||
| 111 | } |
||
| 112 | |||
| 113 | $loadedParentGroup = $this->loadUserGroup($parentGroup->id); |
||
| 114 | |||
| 115 | if ($loadedParentGroup->getVersionInfo()->getContentInfo()->mainLocationId === null) { |
||
| 116 | throw new InvalidArgumentException('parentGroup', 'parent user group has no main location'); |
||
| 117 | } |
||
| 118 | |||
| 119 | $locationCreateStruct = $locationService->newLocationCreateStruct( |
||
| 120 | $loadedParentGroup->getVersionInfo()->getContentInfo()->mainLocationId |
||
| 121 | ); |
||
| 122 | |||
| 123 | $this->repository->beginTransaction(); |
||
| 124 | try { |
||
| 125 | $contentDraft = $contentService->createContent($userGroupCreateStruct, array($locationCreateStruct)); |
||
| 126 | $publishedContent = $contentService->publishVersion($contentDraft->getVersionInfo()); |
||
| 127 | $this->repository->commit(); |
||
| 128 | } catch (Exception $e) { |
||
| 129 | $this->repository->rollback(); |
||
| 130 | throw $e; |
||
| 131 | } |
||
| 132 | |||
| 133 | return $this->buildDomainUserGroupObject($publishedContent); |
||
| 134 | } |
||
| 135 | |||
| 136 | /** |
||
| 137 | * Loads a user group for the given id. |
||
| 138 | * |
||
| 139 | * @param mixed $id |
||
| 140 | * @param string[] $prioritizedLanguages Used as prioritized language code on translated properties of returned object. |
||
| 141 | * |
||
| 142 | * @return \eZ\Publish\API\Repository\Values\User\UserGroup |
||
| 143 | * |
||
| 144 | * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the authenticated user is not allowed to create a user group |
||
| 145 | * @throws \eZ\Publish\API\Repository\Exceptions\NotFoundException if the user group with the given id was not found |
||
| 146 | */ |
||
| 147 | public function loadUserGroup($id, array $prioritizedLanguages = []) |
||
| 148 | { |
||
| 149 | $content = $this->repository->getContentService()->loadContent($id, $prioritizedLanguages); |
||
| 150 | |||
| 151 | return $this->buildDomainUserGroupObject($content); |
||
| 152 | } |
||
| 153 | |||
| 154 | /** |
||
| 155 | * Loads the sub groups of a user group. |
||
| 156 | * |
||
| 157 | * @param \eZ\Publish\API\Repository\Values\User\UserGroup $userGroup |
||
| 158 | * @param int $offset the start offset for paging |
||
| 159 | * @param int $limit the number of user groups returned |
||
| 160 | * @param string[] $prioritizedLanguages Used as prioritized language code on translated properties of returned object. |
||
| 161 | * |
||
| 162 | * @return \eZ\Publish\API\Repository\Values\User\UserGroup[] |
||
| 163 | * |
||
| 164 | * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the authenticated user is not allowed to read the user group |
||
| 165 | */ |
||
| 166 | public function loadSubUserGroups(APIUserGroup $userGroup, $offset = 0, $limit = 25, array $prioritizedLanguages = []) |
||
| 167 | { |
||
| 168 | $locationService = $this->repository->getLocationService(); |
||
| 169 | |||
| 170 | $loadedUserGroup = $this->loadUserGroup($userGroup->id); |
||
| 171 | if (!$this->repository->canUser('content', 'read', $loadedUserGroup)) { |
||
|
|
|||
| 172 | throw new UnauthorizedException('content', 'read'); |
||
| 173 | } |
||
| 174 | |||
| 175 | if ($loadedUserGroup->getVersionInfo()->getContentInfo()->mainLocationId === null) { |
||
| 176 | return array(); |
||
| 177 | } |
||
| 178 | |||
| 179 | $mainGroupLocation = $locationService->loadLocation( |
||
| 180 | $loadedUserGroup->getVersionInfo()->getContentInfo()->mainLocationId |
||
| 181 | ); |
||
| 182 | |||
| 183 | $searchResult = $this->searchSubGroups($mainGroupLocation, $offset, $limit); |
||
| 184 | if ($searchResult->totalCount == 0) { |
||
| 185 | return array(); |
||
| 186 | } |
||
| 187 | |||
| 188 | $subUserGroups = array(); |
||
| 189 | View Code Duplication | foreach ($searchResult->searchHits as $searchHit) { |
|
| 190 | $subUserGroups[] = $this->buildDomainUserGroupObject( |
||
| 191 | $this->repository->getContentService()->internalLoadContent( |
||
| 192 | $searchHit->valueObject->contentInfo->id, |
||
| 193 | $prioritizedLanguages |
||
| 194 | ) |
||
| 195 | ); |
||
| 196 | } |
||
| 197 | |||
| 198 | return $subUserGroups; |
||
| 199 | } |
||
| 200 | |||
| 201 | /** |
||
| 202 | * Returns (searches) subgroups of a user group described by its main location. |
||
| 203 | * |
||
| 204 | * @param \eZ\Publish\API\Repository\Values\Content\Location $location |
||
| 205 | * @param int $offset |
||
| 206 | * @param int $limit |
||
| 207 | * |
||
| 208 | * @return \eZ\Publish\API\Repository\Values\Content\Search\SearchResult |
||
| 209 | */ |
||
| 210 | protected function searchSubGroups(Location $location, $offset = 0, $limit = 25) |
||
| 211 | { |
||
| 212 | $searchQuery = new LocationQuery(); |
||
| 213 | |||
| 214 | $searchQuery->offset = $offset; |
||
| 215 | $searchQuery->limit = $limit; |
||
| 216 | |||
| 217 | $searchQuery->filter = new CriterionLogicalAnd([ |
||
| 218 | new CriterionContentTypeId($this->settings['userGroupClassID']), |
||
| 219 | new CriterionParentLocationId($location->id), |
||
| 220 | ]); |
||
| 221 | |||
| 222 | $searchQuery->sortClauses = $location->getSortClauses(); |
||
| 223 | |||
| 224 | return $this->repository->getSearchService()->findLocations($searchQuery, array(), false); |
||
| 225 | } |
||
| 226 | |||
| 227 | /** |
||
| 228 | * Removes a user group. |
||
| 229 | * |
||
| 230 | * the users which are not assigned to other groups will be deleted. |
||
| 231 | * |
||
| 232 | * @param \eZ\Publish\API\Repository\Values\User\UserGroup $userGroup |
||
| 233 | * |
||
| 234 | * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the authenticated user is not allowed to create a user group |
||
| 235 | */ |
||
| 236 | View Code Duplication | public function deleteUserGroup(APIUserGroup $userGroup) |
|
| 237 | { |
||
| 238 | $loadedUserGroup = $this->loadUserGroup($userGroup->id); |
||
| 239 | |||
| 240 | $this->repository->beginTransaction(); |
||
| 241 | try { |
||
| 242 | //@todo: what happens to sub user groups and users below sub user groups |
||
| 243 | $affectedLocationIds = $this->repository->getContentService()->deleteContent($loadedUserGroup->getVersionInfo()->getContentInfo()); |
||
| 244 | $this->repository->commit(); |
||
| 245 | } catch (Exception $e) { |
||
| 246 | $this->repository->rollback(); |
||
| 247 | throw $e; |
||
| 248 | } |
||
| 249 | |||
| 250 | return $affectedLocationIds; |
||
| 251 | } |
||
| 252 | |||
| 253 | /** |
||
| 254 | * Moves the user group to another parent. |
||
| 255 | * |
||
| 256 | * @param \eZ\Publish\API\Repository\Values\User\UserGroup $userGroup |
||
| 257 | * @param \eZ\Publish\API\Repository\Values\User\UserGroup $newParent |
||
| 258 | * |
||
| 259 | * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the authenticated user is not allowed to move the user group |
||
| 260 | */ |
||
| 261 | public function moveUserGroup(APIUserGroup $userGroup, APIUserGroup $newParent) |
||
| 262 | { |
||
| 263 | $loadedUserGroup = $this->loadUserGroup($userGroup->id); |
||
| 264 | $loadedNewParent = $this->loadUserGroup($newParent->id); |
||
| 265 | |||
| 266 | $locationService = $this->repository->getLocationService(); |
||
| 267 | |||
| 268 | if ($loadedUserGroup->getVersionInfo()->getContentInfo()->mainLocationId === null) { |
||
| 269 | throw new BadStateException('userGroup', 'existing user group is not stored and/or does not have any location yet'); |
||
| 270 | } |
||
| 271 | |||
| 272 | if ($loadedNewParent->getVersionInfo()->getContentInfo()->mainLocationId === null) { |
||
| 273 | throw new BadStateException('newParent', 'new user group is not stored and/or does not have any location yet'); |
||
| 274 | } |
||
| 275 | |||
| 276 | $userGroupMainLocation = $locationService->loadLocation( |
||
| 277 | $loadedUserGroup->getVersionInfo()->getContentInfo()->mainLocationId |
||
| 278 | ); |
||
| 279 | $newParentMainLocation = $locationService->loadLocation( |
||
| 280 | $loadedNewParent->getVersionInfo()->getContentInfo()->mainLocationId |
||
| 281 | ); |
||
| 282 | |||
| 283 | $this->repository->beginTransaction(); |
||
| 284 | try { |
||
| 285 | $locationService->moveSubtree($userGroupMainLocation, $newParentMainLocation); |
||
| 286 | $this->repository->commit(); |
||
| 287 | } catch (Exception $e) { |
||
| 288 | $this->repository->rollback(); |
||
| 289 | throw $e; |
||
| 290 | } |
||
| 291 | } |
||
| 292 | |||
| 293 | /** |
||
| 294 | * Updates the group profile with fields and meta data. |
||
| 295 | * |
||
| 296 | * 4.x: If the versionUpdateStruct is set in $userGroupUpdateStruct, this method internally creates a content draft, updates ts with the provided data |
||
| 297 | * and publishes the draft. If a draft is explicitly required, the user group can be updated via the content service methods. |
||
| 298 | * |
||
| 299 | * @param \eZ\Publish\API\Repository\Values\User\UserGroup $userGroup |
||
| 300 | * @param \eZ\Publish\API\Repository\Values\User\UserGroupUpdateStruct $userGroupUpdateStruct |
||
| 301 | * |
||
| 302 | * @return \eZ\Publish\API\Repository\Values\User\UserGroup |
||
| 303 | * |
||
| 304 | * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the authenticated user is not allowed to update the user group |
||
| 305 | * @throws \eZ\Publish\API\Repository\Exceptions\ContentFieldValidationException if a field in the $userGroupUpdateStruct is not valid |
||
| 306 | * @throws \eZ\Publish\API\Repository\Exceptions\ContentValidationException if a required field is set empty |
||
| 307 | */ |
||
| 308 | public function updateUserGroup(APIUserGroup $userGroup, UserGroupUpdateStruct $userGroupUpdateStruct) |
||
| 309 | { |
||
| 310 | if ($userGroupUpdateStruct->contentUpdateStruct === null && |
||
| 311 | $userGroupUpdateStruct->contentMetadataUpdateStruct === null) { |
||
| 312 | // both update structs are empty, nothing to do |
||
| 313 | return $userGroup; |
||
| 314 | } |
||
| 315 | |||
| 316 | $contentService = $this->repository->getContentService(); |
||
| 317 | |||
| 318 | $loadedUserGroup = $this->loadUserGroup($userGroup->id); |
||
| 319 | |||
| 320 | $this->repository->beginTransaction(); |
||
| 321 | try { |
||
| 322 | $publishedContent = $loadedUserGroup; |
||
| 323 | View Code Duplication | if ($userGroupUpdateStruct->contentUpdateStruct !== null) { |
|
| 324 | $contentDraft = $contentService->createContentDraft($loadedUserGroup->getVersionInfo()->getContentInfo()); |
||
| 325 | |||
| 326 | $contentDraft = $contentService->updateContent( |
||
| 327 | $contentDraft->getVersionInfo(), |
||
| 328 | $userGroupUpdateStruct->contentUpdateStruct |
||
| 329 | ); |
||
| 330 | |||
| 331 | $publishedContent = $contentService->publishVersion($contentDraft->getVersionInfo()); |
||
| 332 | } |
||
| 333 | |||
| 334 | if ($userGroupUpdateStruct->contentMetadataUpdateStruct !== null) { |
||
| 335 | $publishedContent = $contentService->updateContentMetadata( |
||
| 336 | $publishedContent->getVersionInfo()->getContentInfo(), |
||
| 337 | $userGroupUpdateStruct->contentMetadataUpdateStruct |
||
| 338 | ); |
||
| 339 | } |
||
| 340 | |||
| 341 | $this->repository->commit(); |
||
| 342 | } catch (Exception $e) { |
||
| 343 | $this->repository->rollback(); |
||
| 344 | throw $e; |
||
| 345 | } |
||
| 346 | |||
| 347 | return $this->buildDomainUserGroupObject($publishedContent); |
||
| 348 | } |
||
| 349 | |||
| 350 | /** |
||
| 351 | * Create a new user. The created user is published by this method. |
||
| 352 | * |
||
| 353 | * @param \eZ\Publish\API\Repository\Values\User\UserCreateStruct $userCreateStruct the data used for creating the user |
||
| 354 | * @param \eZ\Publish\API\Repository\Values\User\UserGroup[] $parentGroups the groups which are assigned to the user after creation |
||
| 355 | * |
||
| 356 | * @return \eZ\Publish\API\Repository\Values\User\User |
||
| 357 | * |
||
| 358 | * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the authenticated user is not allowed to move the user group |
||
| 359 | * @throws \eZ\Publish\API\Repository\Exceptions\ContentFieldValidationException if a field in the $userCreateStruct is not valid |
||
| 360 | * @throws \eZ\Publish\API\Repository\Exceptions\ContentValidationException if a required field is missing or set to an empty value |
||
| 361 | * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException if a user with provided login already exists |
||
| 362 | */ |
||
| 363 | public function createUser(APIUserCreateStruct $userCreateStruct, array $parentGroups) |
||
| 364 | { |
||
| 365 | if (empty($parentGroups)) { |
||
| 366 | throw new InvalidArgumentValue('parentGroups', $parentGroups); |
||
| 367 | } |
||
| 368 | |||
| 369 | if (!is_string($userCreateStruct->login) || empty($userCreateStruct->login)) { |
||
| 370 | throw new InvalidArgumentValue('login', $userCreateStruct->login, 'UserCreateStruct'); |
||
| 371 | } |
||
| 372 | |||
| 373 | View Code Duplication | if (!is_string($userCreateStruct->email) || empty($userCreateStruct->email)) { |
|
| 374 | throw new InvalidArgumentValue('email', $userCreateStruct->email, 'UserCreateStruct'); |
||
| 375 | } |
||
| 376 | |||
| 377 | if (!ezcMailTools::validateEmailAddress($userCreateStruct->email)) { |
||
| 378 | throw new InvalidArgumentValue('email', $userCreateStruct->email, 'UserCreateStruct'); |
||
| 379 | } |
||
| 380 | |||
| 381 | if (!is_string($userCreateStruct->password) || empty($userCreateStruct->password)) { |
||
| 382 | throw new InvalidArgumentValue('password', $userCreateStruct->password, 'UserCreateStruct'); |
||
| 383 | } |
||
| 384 | |||
| 385 | if (!is_bool($userCreateStruct->enabled)) { |
||
| 386 | throw new InvalidArgumentValue('enabled', $userCreateStruct->enabled, 'UserCreateStruct'); |
||
| 387 | } |
||
| 388 | |||
| 389 | try { |
||
| 390 | $this->userHandler->loadByLogin($userCreateStruct->login); |
||
| 391 | throw new InvalidArgumentException('userCreateStruct', 'User with provided login already exists'); |
||
| 392 | } catch (NotFoundException $e) { |
||
| 393 | // Do nothing |
||
| 394 | } |
||
| 395 | |||
| 396 | $contentService = $this->repository->getContentService(); |
||
| 397 | $locationService = $this->repository->getLocationService(); |
||
| 398 | $contentTypeService = $this->repository->getContentTypeService(); |
||
| 399 | |||
| 400 | if ($userCreateStruct->contentType === null) { |
||
| 401 | $userContentType = $contentTypeService->loadContentType($this->settings['userClassID']); |
||
| 402 | $userCreateStruct->contentType = $userContentType; |
||
| 403 | } |
||
| 404 | |||
| 405 | $locationCreateStructs = array(); |
||
| 406 | foreach ($parentGroups as $parentGroup) { |
||
| 407 | $parentGroup = $this->loadUserGroup($parentGroup->id); |
||
| 408 | if ($parentGroup->getVersionInfo()->getContentInfo()->mainLocationId !== null) { |
||
| 409 | $locationCreateStructs[] = $locationService->newLocationCreateStruct( |
||
| 410 | $parentGroup->getVersionInfo()->getContentInfo()->mainLocationId |
||
| 411 | ); |
||
| 412 | } |
||
| 413 | } |
||
| 414 | |||
| 415 | // Search for the first ezuser field type in content type |
||
| 416 | $userFieldDefinition = null; |
||
| 417 | foreach ($userCreateStruct->contentType->getFieldDefinitions() as $fieldDefinition) { |
||
| 418 | if ($fieldDefinition->fieldTypeIdentifier == 'ezuser') { |
||
| 419 | $userFieldDefinition = $fieldDefinition; |
||
| 420 | break; |
||
| 421 | } |
||
| 422 | } |
||
| 423 | |||
| 424 | if ($userFieldDefinition === null) { |
||
| 425 | throw new ContentValidationException('Provided content type does not contain ezuser field type'); |
||
| 426 | } |
||
| 427 | |||
| 428 | $fixUserFieldType = true; |
||
| 429 | foreach ($userCreateStruct->fields as $index => $field) { |
||
| 430 | if ($field->fieldDefIdentifier == $userFieldDefinition->identifier) { |
||
| 431 | if ($field->value instanceof UserValue) { |
||
| 432 | $userCreateStruct->fields[$index]->value->login = $userCreateStruct->login; |
||
| 433 | } else { |
||
| 434 | $userCreateStruct->fields[$index]->value = new UserValue( |
||
| 435 | array( |
||
| 436 | 'login' => $userCreateStruct->login, |
||
| 437 | ) |
||
| 438 | ); |
||
| 439 | } |
||
| 440 | |||
| 441 | $fixUserFieldType = false; |
||
| 442 | } |
||
| 443 | } |
||
| 444 | |||
| 445 | if ($fixUserFieldType) { |
||
| 446 | $userCreateStruct->setField( |
||
| 447 | $userFieldDefinition->identifier, |
||
| 448 | new UserValue( |
||
| 449 | array( |
||
| 450 | 'login' => $userCreateStruct->login, |
||
| 451 | ) |
||
| 452 | ) |
||
| 453 | ); |
||
| 454 | } |
||
| 455 | |||
| 456 | $this->repository->beginTransaction(); |
||
| 457 | try { |
||
| 458 | $contentDraft = $contentService->createContent($userCreateStruct, $locationCreateStructs); |
||
| 459 | // Create user before publishing, so that external data can be returned |
||
| 460 | $spiUser = $this->userHandler->create( |
||
| 461 | new SPIUser( |
||
| 462 | array( |
||
| 463 | 'id' => $contentDraft->id, |
||
| 464 | 'login' => $userCreateStruct->login, |
||
| 465 | 'email' => $userCreateStruct->email, |
||
| 466 | 'passwordHash' => $this->createPasswordHash( |
||
| 467 | $userCreateStruct->login, |
||
| 468 | $userCreateStruct->password, |
||
| 469 | $this->settings['siteName'], |
||
| 470 | $this->settings['hashType'] |
||
| 471 | ), |
||
| 472 | 'hashAlgorithm' => $this->settings['hashType'], |
||
| 473 | 'isEnabled' => $userCreateStruct->enabled, |
||
| 474 | 'maxLogin' => 0, |
||
| 475 | ) |
||
| 476 | ) |
||
| 477 | ); |
||
| 478 | $publishedContent = $contentService->publishVersion($contentDraft->getVersionInfo()); |
||
| 479 | |||
| 480 | $this->repository->commit(); |
||
| 481 | } catch (Exception $e) { |
||
| 482 | $this->repository->rollback(); |
||
| 483 | throw $e; |
||
| 484 | } |
||
| 485 | |||
| 486 | return $this->buildDomainUserObject($spiUser, $publishedContent); |
||
| 487 | } |
||
| 488 | |||
| 489 | /** |
||
| 490 | * Loads a user. |
||
| 491 | * |
||
| 492 | * @param mixed $userId |
||
| 493 | * @param string[] $prioritizedLanguages Used as prioritized language code on translated properties of returned object. |
||
| 494 | * |
||
| 495 | * @return \eZ\Publish\API\Repository\Values\User\User |
||
| 496 | * |
||
| 497 | * @throws \eZ\Publish\API\Repository\Exceptions\NotFoundException if a user with the given id was not found |
||
| 498 | */ |
||
| 499 | public function loadUser($userId, array $prioritizedLanguages = []) |
||
| 500 | { |
||
| 501 | /** @var \eZ\Publish\API\Repository\Values\Content\Content $content */ |
||
| 502 | $content = $this->repository->getContentService()->internalLoadContent($userId, $prioritizedLanguages); |
||
| 503 | // Get spiUser value from Field Value |
||
| 504 | foreach ($content->getFields() as $field) { |
||
| 505 | if (!$field->value instanceof UserValue) { |
||
| 506 | continue; |
||
| 507 | } |
||
| 508 | |||
| 509 | /** @var \eZ\Publish\Core\FieldType\User\Value $value */ |
||
| 510 | $value = $field->value; |
||
| 511 | $spiUser = new SPIUser(); |
||
| 512 | $spiUser->id = $value->contentId; |
||
| 513 | $spiUser->login = $value->login; |
||
| 514 | $spiUser->email = $value->email; |
||
| 515 | $spiUser->hashAlgorithm = $value->passwordHashType; |
||
| 516 | $spiUser->passwordHash = $value->passwordHash; |
||
| 517 | $spiUser->isEnabled = $value->enabled; |
||
| 518 | $spiUser->maxLogin = $value->maxLogin; |
||
| 519 | break; |
||
| 520 | } |
||
| 521 | |||
| 522 | // If for some reason not found, load it |
||
| 523 | if (!isset($spiUser)) { |
||
| 524 | $spiUser = $this->userHandler->load($userId); |
||
| 525 | } |
||
| 526 | |||
| 527 | return $this->buildDomainUserObject($spiUser, $content); |
||
| 528 | } |
||
| 529 | |||
| 530 | /** |
||
| 531 | * Loads anonymous user. |
||
| 532 | * |
||
| 533 | * @deprecated since 5.3, use loadUser( $anonymousUserId ) instead |
||
| 534 | * |
||
| 535 | * @uses ::loadUser() |
||
| 536 | * |
||
| 537 | * @return \eZ\Publish\API\Repository\Values\User\User |
||
| 538 | */ |
||
| 539 | public function loadAnonymousUser() |
||
| 540 | { |
||
| 541 | return $this->loadUser($this->settings['anonymousUserID']); |
||
| 542 | } |
||
| 543 | |||
| 544 | /** |
||
| 545 | * Loads a user for the given login and password. |
||
| 546 | * |
||
| 547 | * {@inheritdoc} |
||
| 548 | * |
||
| 549 | * @param string $login |
||
| 550 | * @param string $password the plain password |
||
| 551 | * @param string[] $prioritizedLanguages Used as prioritized language code on translated properties of returned object. |
||
| 552 | * |
||
| 553 | * @return \eZ\Publish\API\Repository\Values\User\User |
||
| 554 | * |
||
| 555 | * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException if credentials are invalid |
||
| 556 | * @throws \eZ\Publish\API\Repository\Exceptions\NotFoundException if a user with the given credentials was not found |
||
| 557 | */ |
||
| 558 | public function loadUserByCredentials($login, $password, array $prioritizedLanguages = []) |
||
| 559 | { |
||
| 560 | if (!is_string($login) || empty($login)) { |
||
| 561 | throw new InvalidArgumentValue('login', $login); |
||
| 562 | } |
||
| 563 | |||
| 564 | if (!is_string($password)) { |
||
| 565 | throw new InvalidArgumentValue('password', $password); |
||
| 566 | } |
||
| 567 | |||
| 568 | // Randomize login time to protect against timing attacks |
||
| 569 | usleep(mt_rand(0, 30000)); |
||
| 570 | |||
| 571 | $spiUser = $this->userHandler->loadByLogin($login); |
||
| 572 | $passwordHash = $this->createPasswordHash( |
||
| 573 | $login, |
||
| 574 | $password, |
||
| 575 | $this->settings['siteName'], |
||
| 576 | $spiUser->hashAlgorithm |
||
| 577 | ); |
||
| 578 | |||
| 579 | if ($spiUser->passwordHash !== $passwordHash) { |
||
| 580 | throw new NotFoundException('user', $login); |
||
| 581 | } |
||
| 582 | |||
| 583 | return $this->buildDomainUserObject($spiUser, null, $prioritizedLanguages); |
||
| 584 | } |
||
| 585 | |||
| 586 | /** |
||
| 587 | * Loads a user for the given login. |
||
| 588 | * |
||
| 589 | * {@inheritdoc} |
||
| 590 | * |
||
| 591 | * @param string $login |
||
| 592 | * @param string[] $prioritizedLanguages Used as prioritized language code on translated properties of returned object. |
||
| 593 | * |
||
| 594 | * @return \eZ\Publish\API\Repository\Values\User\User |
||
| 595 | * |
||
| 596 | * @throws \eZ\Publish\API\Repository\Exceptions\NotFoundException if a user with the given credentials was not found |
||
| 597 | */ |
||
| 598 | public function loadUserByLogin($login, array $prioritizedLanguages = []) |
||
| 599 | { |
||
| 600 | if (!is_string($login) || empty($login)) { |
||
| 601 | throw new InvalidArgumentValue('login', $login); |
||
| 602 | } |
||
| 603 | |||
| 604 | $spiUser = $this->userHandler->loadByLogin($login); |
||
| 605 | |||
| 606 | return $this->buildDomainUserObject($spiUser, null, $prioritizedLanguages); |
||
| 607 | } |
||
| 608 | |||
| 609 | /** |
||
| 610 | * Loads a user for the given email. |
||
| 611 | * |
||
| 612 | * {@inheritdoc} |
||
| 613 | * |
||
| 614 | * @param string $email |
||
| 615 | * @param string[] $prioritizedLanguages Used as prioritized language code on translated properties of returned object. |
||
| 616 | * |
||
| 617 | * @return \eZ\Publish\API\Repository\Values\User\User[] |
||
| 618 | */ |
||
| 619 | public function loadUsersByEmail($email, array $prioritizedLanguages = []) |
||
| 620 | { |
||
| 621 | if (!is_string($email) || empty($email)) { |
||
| 622 | throw new InvalidArgumentValue('email', $email); |
||
| 623 | } |
||
| 624 | |||
| 625 | $users = array(); |
||
| 626 | foreach ($this->userHandler->loadByEmail($email) as $spiUser) { |
||
| 627 | $users[] = $this->buildDomainUserObject($spiUser, null, $prioritizedLanguages); |
||
| 628 | } |
||
| 629 | |||
| 630 | return $users; |
||
| 631 | } |
||
| 632 | |||
| 633 | /** |
||
| 634 | * This method deletes a user. |
||
| 635 | * |
||
| 636 | * @param \eZ\Publish\API\Repository\Values\User\User $user |
||
| 637 | * |
||
| 638 | * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the authenticated user is not allowed to delete the user |
||
| 639 | */ |
||
| 640 | View Code Duplication | public function deleteUser(APIUser $user) |
|
| 641 | { |
||
| 642 | $loadedUser = $this->loadUser($user->id); |
||
| 643 | |||
| 644 | $this->repository->beginTransaction(); |
||
| 645 | try { |
||
| 646 | $affectedLocationIds = $this->repository->getContentService()->deleteContent($loadedUser->getVersionInfo()->getContentInfo()); |
||
| 647 | $this->userHandler->delete($loadedUser->id); |
||
| 648 | $this->repository->commit(); |
||
| 649 | } catch (Exception $e) { |
||
| 650 | $this->repository->rollback(); |
||
| 651 | throw $e; |
||
| 652 | } |
||
| 653 | |||
| 654 | return $affectedLocationIds; |
||
| 655 | } |
||
| 656 | |||
| 657 | /** |
||
| 658 | * Updates a user. |
||
| 659 | * |
||
| 660 | * 4.x: If the versionUpdateStruct is set in the user update structure, this method internally creates a content draft, updates ts with the provided data |
||
| 661 | * and publishes the draft. If a draft is explicitly required, the user group can be updated via the content service methods. |
||
| 662 | * |
||
| 663 | * @param \eZ\Publish\API\Repository\Values\User\User $user |
||
| 664 | * @param \eZ\Publish\API\Repository\Values\User\UserUpdateStruct $userUpdateStruct |
||
| 665 | * |
||
| 666 | * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the authenticated user is not allowed to update the user |
||
| 667 | * @throws \eZ\Publish\API\Repository\Exceptions\ContentFieldValidationException if a field in the $userUpdateStruct is not valid |
||
| 668 | * @throws \eZ\Publish\API\Repository\Exceptions\ContentValidationException if a required field is set empty |
||
| 669 | * |
||
| 670 | * @return \eZ\Publish\API\Repository\Values\User\User |
||
| 671 | */ |
||
| 672 | public function updateUser(APIUser $user, UserUpdateStruct $userUpdateStruct) |
||
| 673 | { |
||
| 674 | $loadedUser = $this->loadUser($user->id); |
||
| 675 | |||
| 676 | // We need to determine if we have anything to update. |
||
| 677 | // UserUpdateStruct is specific as some of the new content is in |
||
| 678 | // content update struct and some of it is in additional fields like |
||
| 679 | // email, password and so on |
||
| 680 | $doUpdate = false; |
||
| 681 | foreach ($userUpdateStruct as $propertyValue) { |
||
| 682 | if ($propertyValue !== null) { |
||
| 683 | $doUpdate = true; |
||
| 684 | break; |
||
| 685 | } |
||
| 686 | } |
||
| 687 | |||
| 688 | if (!$doUpdate) { |
||
| 689 | // Nothing to update, so we just quit |
||
| 690 | return $user; |
||
| 691 | } |
||
| 692 | |||
| 693 | if ($userUpdateStruct->email !== null) { |
||
| 694 | View Code Duplication | if (!is_string($userUpdateStruct->email) || empty($userUpdateStruct->email)) { |
|
| 695 | throw new InvalidArgumentValue('email', $userUpdateStruct->email, 'UserUpdateStruct'); |
||
| 696 | } |
||
| 697 | |||
| 698 | if (!ezcMailTools::validateEmailAddress($userUpdateStruct->email)) { |
||
| 699 | throw new InvalidArgumentValue('email', $userUpdateStruct->email, 'UserUpdateStruct'); |
||
| 700 | } |
||
| 701 | } |
||
| 702 | |||
| 703 | View Code Duplication | if ($userUpdateStruct->password !== null && (!is_string($userUpdateStruct->password) || empty($userUpdateStruct->password))) { |
|
| 704 | throw new InvalidArgumentValue('password', $userUpdateStruct->password, 'UserUpdateStruct'); |
||
| 705 | } |
||
| 706 | |||
| 707 | if ($userUpdateStruct->enabled !== null && !is_bool($userUpdateStruct->enabled)) { |
||
| 708 | throw new InvalidArgumentValue('enabled', $userUpdateStruct->enabled, 'UserUpdateStruct'); |
||
| 709 | } |
||
| 710 | |||
| 711 | if ($userUpdateStruct->maxLogin !== null && !is_int($userUpdateStruct->maxLogin)) { |
||
| 712 | throw new InvalidArgumentValue('maxLogin', $userUpdateStruct->maxLogin, 'UserUpdateStruct'); |
||
| 713 | } |
||
| 714 | |||
| 715 | $contentService = $this->repository->getContentService(); |
||
| 716 | |||
| 717 | if (!$this->repository->canUser('content', 'edit', $loadedUser)) { |
||
| 718 | throw new UnauthorizedException('content', 'edit'); |
||
| 719 | } |
||
| 720 | |||
| 721 | $this->repository->beginTransaction(); |
||
| 722 | try { |
||
| 723 | $publishedContent = $loadedUser; |
||
| 724 | View Code Duplication | if ($userUpdateStruct->contentUpdateStruct !== null) { |
|
| 725 | $contentDraft = $contentService->createContentDraft($loadedUser->getVersionInfo()->getContentInfo()); |
||
| 726 | $contentDraft = $contentService->updateContent( |
||
| 727 | $contentDraft->getVersionInfo(), |
||
| 728 | $userUpdateStruct->contentUpdateStruct |
||
| 729 | ); |
||
| 730 | $publishedContent = $contentService->publishVersion($contentDraft->getVersionInfo()); |
||
| 731 | } |
||
| 732 | |||
| 733 | if ($userUpdateStruct->contentMetadataUpdateStruct !== null) { |
||
| 734 | $contentService->updateContentMetadata( |
||
| 735 | $publishedContent->getVersionInfo()->getContentInfo(), |
||
| 736 | $userUpdateStruct->contentMetadataUpdateStruct |
||
| 737 | ); |
||
| 738 | } |
||
| 739 | |||
| 740 | $this->userHandler->update( |
||
| 741 | new SPIUser( |
||
| 742 | array( |
||
| 743 | 'id' => $loadedUser->id, |
||
| 744 | 'login' => $loadedUser->login, |
||
| 745 | 'email' => $userUpdateStruct->email ?: $loadedUser->email, |
||
| 746 | 'passwordHash' => $userUpdateStruct->password ? |
||
| 747 | $this->createPasswordHash( |
||
| 748 | $loadedUser->login, |
||
| 749 | $userUpdateStruct->password, |
||
| 750 | $this->settings['siteName'], |
||
| 751 | $this->settings['hashType'] |
||
| 752 | ) : |
||
| 753 | $loadedUser->passwordHash, |
||
| 754 | 'hashAlgorithm' => $this->settings['hashType'], |
||
| 755 | 'isEnabled' => $userUpdateStruct->enabled !== null ? $userUpdateStruct->enabled : $loadedUser->enabled, |
||
| 756 | 'maxLogin' => $userUpdateStruct->maxLogin !== null ? (int)$userUpdateStruct->maxLogin : $loadedUser->maxLogin, |
||
| 757 | ) |
||
| 758 | ) |
||
| 759 | ); |
||
| 760 | |||
| 761 | $this->repository->commit(); |
||
| 762 | } catch (Exception $e) { |
||
| 763 | $this->repository->rollback(); |
||
| 764 | throw $e; |
||
| 765 | } |
||
| 766 | |||
| 767 | return $this->loadUser($loadedUser->id); |
||
| 768 | } |
||
| 769 | |||
| 770 | /** |
||
| 771 | * Assigns a new user group to the user. |
||
| 772 | * |
||
| 773 | * @param \eZ\Publish\API\Repository\Values\User\User $user |
||
| 774 | * @param \eZ\Publish\API\Repository\Values\User\UserGroup $userGroup |
||
| 775 | * |
||
| 776 | * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the authenticated user is not allowed to assign the user group to the user |
||
| 777 | * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException if the user is already in the given user group |
||
| 778 | */ |
||
| 779 | public function assignUserToUserGroup(APIUser $user, APIUserGroup $userGroup) |
||
| 780 | { |
||
| 781 | $loadedUser = $this->loadUser($user->id); |
||
| 782 | $loadedGroup = $this->loadUserGroup($userGroup->id); |
||
| 783 | $locationService = $this->repository->getLocationService(); |
||
| 784 | |||
| 785 | $existingGroupIds = array(); |
||
| 786 | $userLocations = $locationService->loadLocations($loadedUser->getVersionInfo()->getContentInfo()); |
||
| 787 | foreach ($userLocations as $userLocation) { |
||
| 788 | $existingGroupIds[] = $userLocation->parentLocationId; |
||
| 789 | } |
||
| 790 | |||
| 791 | if ($loadedGroup->getVersionInfo()->getContentInfo()->mainLocationId === null) { |
||
| 792 | throw new BadStateException('userGroup', 'user group has no main location or no locations'); |
||
| 793 | } |
||
| 794 | |||
| 795 | if (in_array($loadedGroup->getVersionInfo()->getContentInfo()->mainLocationId, $existingGroupIds)) { |
||
| 796 | // user is already assigned to the user group |
||
| 797 | throw new InvalidArgumentException('user', 'user is already in the given user group'); |
||
| 798 | } |
||
| 799 | |||
| 800 | $locationCreateStruct = $locationService->newLocationCreateStruct( |
||
| 801 | $loadedGroup->getVersionInfo()->getContentInfo()->mainLocationId |
||
| 802 | ); |
||
| 803 | |||
| 804 | $this->repository->beginTransaction(); |
||
| 805 | try { |
||
| 806 | $locationService->createLocation( |
||
| 807 | $loadedUser->getVersionInfo()->getContentInfo(), |
||
| 808 | $locationCreateStruct |
||
| 809 | ); |
||
| 810 | $this->repository->commit(); |
||
| 811 | } catch (Exception $e) { |
||
| 812 | $this->repository->rollback(); |
||
| 813 | throw $e; |
||
| 814 | } |
||
| 815 | } |
||
| 816 | |||
| 817 | /** |
||
| 818 | * Removes a user group from the user. |
||
| 819 | * |
||
| 820 | * @param \eZ\Publish\API\Repository\Values\User\User $user |
||
| 821 | * @param \eZ\Publish\API\Repository\Values\User\UserGroup $userGroup |
||
| 822 | * |
||
| 823 | * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the authenticated user is not allowed to remove the user group from the user |
||
| 824 | * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException if the user is not in the given user group |
||
| 825 | * @throws \eZ\Publish\API\Repository\Exceptions\BadStateException If $userGroup is the last assigned user group |
||
| 826 | */ |
||
| 827 | public function unAssignUserFromUserGroup(APIUser $user, APIUserGroup $userGroup) |
||
| 828 | { |
||
| 829 | $loadedUser = $this->loadUser($user->id); |
||
| 830 | $loadedGroup = $this->loadUserGroup($userGroup->id); |
||
| 831 | $locationService = $this->repository->getLocationService(); |
||
| 832 | |||
| 833 | $userLocations = $locationService->loadLocations($loadedUser->getVersionInfo()->getContentInfo()); |
||
| 834 | if (empty($userLocations)) { |
||
| 835 | throw new BadStateException('user', 'user has no locations, cannot unassign from group'); |
||
| 836 | } |
||
| 837 | |||
| 838 | if ($loadedGroup->getVersionInfo()->getContentInfo()->mainLocationId === null) { |
||
| 839 | throw new BadStateException('userGroup', 'user group has no main location or no locations, cannot unassign'); |
||
| 840 | } |
||
| 841 | |||
| 842 | foreach ($userLocations as $userLocation) { |
||
| 843 | if ($userLocation->parentLocationId == $loadedGroup->getVersionInfo()->getContentInfo()->mainLocationId) { |
||
| 844 | // Throw this specific BadState when we know argument is valid |
||
| 845 | if (count($userLocations) === 1) { |
||
| 846 | throw new BadStateException('user', 'user only has one user group, cannot unassign from last group'); |
||
| 847 | } |
||
| 848 | |||
| 849 | $this->repository->beginTransaction(); |
||
| 850 | try { |
||
| 851 | $locationService->deleteLocation($userLocation); |
||
| 852 | $this->repository->commit(); |
||
| 853 | |||
| 854 | return; |
||
| 855 | } catch (Exception $e) { |
||
| 856 | $this->repository->rollback(); |
||
| 857 | throw $e; |
||
| 858 | } |
||
| 859 | } |
||
| 860 | } |
||
| 861 | |||
| 862 | throw new InvalidArgumentException('userGroup', 'user is not in the given user group'); |
||
| 863 | } |
||
| 864 | |||
| 865 | /** |
||
| 866 | * Loads the user groups the user belongs to. |
||
| 867 | * |
||
| 868 | * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the authenticated user is not allowed read the user or user group |
||
| 869 | * |
||
| 870 | * @param \eZ\Publish\API\Repository\Values\User\User $user |
||
| 871 | * @param int $offset the start offset for paging |
||
| 872 | * @param int $limit the number of user groups returned |
||
| 873 | * @param string[] $prioritizedLanguages Used as prioritized language code on translated properties of returned object. |
||
| 874 | * |
||
| 875 | * @return \eZ\Publish\API\Repository\Values\User\UserGroup[] |
||
| 876 | */ |
||
| 877 | public function loadUserGroupsOfUser(APIUser $user, $offset = 0, $limit = 25, array $prioritizedLanguages = []) |
||
| 878 | { |
||
| 879 | $locationService = $this->repository->getLocationService(); |
||
| 880 | |||
| 881 | if (!$this->repository->getPermissionResolver()->canUser('content', 'read', $user)) { |
||
| 882 | throw new UnauthorizedException('content', 'read'); |
||
| 883 | } |
||
| 884 | |||
| 885 | $userLocations = $locationService->loadLocations( |
||
| 886 | $user->getVersionInfo()->getContentInfo() |
||
| 887 | ); |
||
| 888 | |||
| 889 | $parentLocationIds = array(); |
||
| 890 | foreach ($userLocations as $userLocation) { |
||
| 891 | if ($userLocation->parentLocationId !== null) { |
||
| 892 | $parentLocationIds[] = $userLocation->parentLocationId; |
||
| 893 | } |
||
| 894 | } |
||
| 895 | |||
| 896 | $searchQuery = new LocationQuery(); |
||
| 897 | |||
| 898 | $searchQuery->offset = $offset; |
||
| 899 | $searchQuery->limit = $limit; |
||
| 900 | $searchQuery->performCount = false; |
||
| 901 | |||
| 902 | $searchQuery->filter = new CriterionLogicalAnd( |
||
| 903 | [ |
||
| 904 | new CriterionContentTypeId($this->settings['userGroupClassID']), |
||
| 905 | new CriterionLocationId($parentLocationIds), |
||
| 906 | ] |
||
| 907 | ); |
||
| 908 | |||
| 909 | $searchResult = $this->repository->getSearchService()->findLocations($searchQuery); |
||
| 910 | |||
| 911 | $userGroups = []; |
||
| 912 | View Code Duplication | foreach ($searchResult->searchHits as $resultItem) { |
|
| 913 | $userGroups[] = $this->buildDomainUserGroupObject( |
||
| 914 | $this->repository->getContentService()->internalLoadContent( |
||
| 915 | $resultItem->valueObject->contentInfo->id, |
||
| 916 | $prioritizedLanguages |
||
| 917 | ) |
||
| 918 | ); |
||
| 919 | } |
||
| 920 | |||
| 921 | return $userGroups; |
||
| 922 | } |
||
| 923 | |||
| 924 | /** |
||
| 925 | * Loads the users of a user group. |
||
| 926 | * |
||
| 927 | * @throws \eZ\Publish\API\Repository\Exceptions\UnauthorizedException if the authenticated user is not allowed to read the users or user group |
||
| 928 | * |
||
| 929 | * @param \eZ\Publish\API\Repository\Values\User\UserGroup $userGroup |
||
| 930 | * @param int $offset the start offset for paging |
||
| 931 | * @param int $limit the number of users returned |
||
| 932 | * @param string[] $prioritizedLanguages Used as prioritized language code on translated properties of returned object. |
||
| 933 | * |
||
| 934 | * @return \eZ\Publish\API\Repository\Values\User\User[] |
||
| 935 | */ |
||
| 936 | public function loadUsersOfUserGroup( |
||
| 937 | APIUserGroup $userGroup, |
||
| 938 | $offset = 0, |
||
| 939 | $limit = 25, |
||
| 940 | array $prioritizedLanguages = [] |
||
| 941 | ) { |
||
| 942 | $loadedUserGroup = $this->loadUserGroup($userGroup->id); |
||
| 943 | |||
| 944 | if ($loadedUserGroup->getVersionInfo()->getContentInfo()->mainLocationId === null) { |
||
| 945 | return []; |
||
| 946 | } |
||
| 947 | |||
| 948 | $mainGroupLocation = $this->repository->getLocationService()->loadLocation( |
||
| 949 | $loadedUserGroup->getVersionInfo()->getContentInfo()->mainLocationId |
||
| 950 | ); |
||
| 951 | |||
| 952 | $searchQuery = new LocationQuery(); |
||
| 953 | |||
| 954 | $searchQuery->filter = new CriterionLogicalAnd( |
||
| 955 | [ |
||
| 956 | new CriterionContentTypeId($this->settings['userClassID']), |
||
| 957 | new CriterionParentLocationId($mainGroupLocation->id), |
||
| 958 | ] |
||
| 959 | ); |
||
| 960 | |||
| 961 | $searchQuery->offset = $offset; |
||
| 962 | $searchQuery->limit = $limit; |
||
| 963 | $searchQuery->performCount = false; |
||
| 964 | $searchQuery->sortClauses = $mainGroupLocation->getSortClauses(); |
||
| 965 | |||
| 966 | $searchResult = $this->repository->getSearchService()->findLocations($searchQuery); |
||
| 967 | |||
| 968 | $users = []; |
||
| 969 | foreach ($searchResult->searchHits as $resultItem) { |
||
| 970 | $users[] = $this->buildDomainUserObject( |
||
| 971 | $this->userHandler->load($resultItem->valueObject->contentInfo->id), |
||
| 972 | $this->repository->getContentService()->internalLoadContent( |
||
| 973 | $resultItem->valueObject->contentInfo->id, |
||
| 974 | $prioritizedLanguages |
||
| 975 | ) |
||
| 976 | ); |
||
| 977 | } |
||
| 978 | |||
| 979 | return $users; |
||
| 980 | } |
||
| 981 | |||
| 982 | /** |
||
| 983 | * Instantiate a user create class. |
||
| 984 | * |
||
| 985 | * @param string $login the login of the new user |
||
| 986 | * @param string $email the email of the new user |
||
| 987 | * @param string $password the plain password of the new user |
||
| 988 | * @param string $mainLanguageCode the main language for the underlying content object |
||
| 989 | * @param \eZ\Publish\API\Repository\Values\ContentType\ContentType $contentType 5.x the content type for the underlying content object. In 4.x it is ignored and taken from the configuration |
||
| 990 | * |
||
| 991 | * @return \eZ\Publish\API\Repository\Values\User\UserCreateStruct |
||
| 992 | */ |
||
| 993 | public function newUserCreateStruct($login, $email, $password, $mainLanguageCode, $contentType = null) |
||
| 1013 | |||
| 1014 | /** |
||
| 1015 | * Instantiate a user group create class. |
||
| 1016 | * |
||
| 1017 | * @param string $mainLanguageCode The main language for the underlying content object |
||
| 1018 | * @param null|\eZ\Publish\API\Repository\Values\ContentType\ContentType $contentType 5.x the content type for the underlying content object. In 4.x it is ignored and taken from the configuration |
||
| 1019 | * |
||
| 1020 | * @return \eZ\Publish\API\Repository\Values\User\UserGroupCreateStruct |
||
| 1021 | */ |
||
| 1022 | public function newUserGroupCreateStruct($mainLanguageCode, $contentType = null) |
||
| 1038 | |||
| 1039 | /** |
||
| 1040 | * Instantiate a new user update struct. |
||
| 1041 | * |
||
| 1042 | * @return \eZ\Publish\API\Repository\Values\User\UserUpdateStruct |
||
| 1043 | */ |
||
| 1044 | public function newUserUpdateStruct() |
||
| 1048 | |||
| 1049 | /** |
||
| 1050 | * Instantiate a new user group update struct. |
||
| 1051 | * |
||
| 1052 | * @return \eZ\Publish\API\Repository\Values\User\UserGroupUpdateStruct |
||
| 1053 | */ |
||
| 1054 | public function newUserGroupUpdateStruct() |
||
| 1058 | |||
| 1059 | /** |
||
| 1060 | * Builds the domain UserGroup object from provided Content object. |
||
| 1061 | * |
||
| 1062 | * @param \eZ\Publish\API\Repository\Values\Content\Content $content |
||
| 1063 | * |
||
| 1064 | * @return \eZ\Publish\API\Repository\Values\User\UserGroup |
||
| 1065 | */ |
||
| 1066 | protected function buildDomainUserGroupObject(APIContent $content) |
||
| 1088 | |||
| 1089 | /** |
||
| 1090 | * Builds the domain user object from provided persistence user object. |
||
| 1091 | * |
||
| 1092 | * @param \eZ\Publish\SPI\Persistence\User $spiUser |
||
| 1093 | * @param \eZ\Publish\API\Repository\Values\Content\Content|null $content |
||
| 1094 | * @param string[] $prioritizedLanguages Used as prioritized language code on translated properties of returned object. |
||
| 1095 | * |
||
| 1096 | * @return \eZ\Publish\API\Repository\Values\User\User |
||
| 1097 | */ |
||
| 1098 | protected function buildDomainUserObject( |
||
| 1099 | SPIUser $spiUser, |
||
| 1100 | APIContent $content = null, |
||
| 1101 | array $prioritizedLanguages = [] |
||
| 1102 | ) { |
||
| 1103 | if ($content === null) { |
||
| 1104 | $content = $this->repository->getContentService()->internalLoadContent( |
||
| 1105 | $spiUser->id, |
||
| 1106 | $prioritizedLanguages |
||
| 1107 | ); |
||
| 1108 | } |
||
| 1122 | |||
| 1123 | /** |
||
| 1124 | * Returns password hash based on user data and site settings. |
||
| 1125 | * |
||
| 1126 | * @param string $login User login |
||
| 1127 | * @param string $password User password |
||
| 1128 | * @param string $site The name of the site |
||
| 1129 | * @param int $type Type of password to generate |
||
| 1130 | * |
||
| 1131 | * @return string Generated password hash |
||
| 1132 | */ |
||
| 1133 | protected function createPasswordHash($login, $password, $site, $type) |
||
| 1152 | } |
||
| 1153 |
Loading history...
This method has been deprecated. The supplier of the class has supplied an explanatory message.
The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead.