Code Duplication - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Code Duplication Length = 20-25 lines in 35 locations

eZ/Publish/Core/Event/ContentService.php 2 locations


        return $content;
    }

    public function deleteContent(ContentInfo $contentInfo): array
    {
        $eventData = [$contentInfo];

        $beforeEvent = new BeforeDeleteContentEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(ContentEvents::BEFORE_DELETE_CONTENT, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $locations = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::deleteContent($contentInfo);

        $this->eventDispatcher->dispatch(
            ContentEvents::DELETE_CONTENT,
            new DeleteContentEvent($locations, ...$eventData)
        );

        return $locations;
    }

    public function createContentDraft(
        ContentInfo $contentInfo,

        return $content;
    }

    public function publishVersion(VersionInfo $versionInfo): Content
    {
        $eventData = [$versionInfo];

        $beforeEvent = new BeforePublishVersionEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(ContentEvents::BEFORE_PUBLISH_VERSION, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $content = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::publishVersion($versionInfo);

        $this->eventDispatcher->dispatch(
            ContentEvents::PUBLISH_VERSION,
            new PublishVersionEvent($content, ...$eventData)
        );

        return $content;
    }

    public function deleteVersion(VersionInfo $versionInfo): void
    {

eZ/Publish/Core/Event/ContentTypeService.php 4 locations


        $this->eventDispatcher = $eventDispatcher;
    }

    public function createContentTypeGroup(ContentTypeGroupCreateStruct $contentTypeGroupCreateStruct)
    {
        $eventData = [$contentTypeGroupCreateStruct];

        $beforeEvent = new BeforeCreateContentTypeGroupEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(ContentTypeEvents::BEFORE_CREATE_CONTENT_TYPE_GROUP, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $contentTypeGroup = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::createContentTypeGroup($contentTypeGroupCreateStruct);

        $this->eventDispatcher->dispatch(
            ContentTypeEvents::CREATE_CONTENT_TYPE_GROUP,
            new CreateContentTypeGroupEvent($contentTypeGroup, ...$eventData)
        );

        return $contentTypeGroup;
    }

    public function updateContentTypeGroup(
        ContentTypeGroup $contentTypeGroup,

        );
    }

    public function createContentType(
        ContentTypeCreateStruct $contentTypeCreateStruct,
        array $contentTypeGroups
    ) {
        $eventData = [
            $contentTypeCreateStruct,
            $contentTypeGroups,
        ];

        $beforeEvent = new BeforeCreateContentTypeEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(ContentTypeEvents::BEFORE_CREATE_CONTENT_TYPE, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $contentTypeDraft = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::createContentType($contentTypeCreateStruct, $contentTypeGroups);

        $this->eventDispatcher->dispatch(
            ContentTypeEvents::CREATE_CONTENT_TYPE,
            new CreateContentTypeEvent($contentTypeDraft, ...$eventData)
        );

        return $contentTypeDraft;
    }

    public function createContentTypeDraft(ContentType $contentType)
    {

        return $contentTypeDraft;
    }

    public function createContentTypeDraft(ContentType $contentType)
    {
        $eventData = [$contentType];

        $beforeEvent = new BeforeCreateContentTypeDraftEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(ContentTypeEvents::BEFORE_CREATE_CONTENT_TYPE_DRAFT, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $contentTypeDraft = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::createContentTypeDraft($contentType);

        $this->eventDispatcher->dispatch(
            ContentTypeEvents::CREATE_CONTENT_TYPE_DRAFT,
            new CreateContentTypeDraftEvent($contentTypeDraft, ...$eventData)
        );

        return $contentTypeDraft;
    }

    public function updateContentTypeDraft(
        ContentTypeDraft $contentTypeDraft,

        );
    }

    public function removeContentTypeTranslation(
        ContentTypeDraft $contentTypeDraft,
        string $languageCode
    ): ContentTypeDraft {
        $eventData = [
            $contentTypeDraft,
            $languageCode,
        ];

        $beforeEvent = new BeforeRemoveContentTypeTranslationEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(ContentTypeEvents::BEFORE_REMOVE_CONTENT_TYPE_TRANSLATION, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $newContentTypeDraft = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::removeContentTypeTranslation($contentTypeDraft, $languageCode);

        $this->eventDispatcher->dispatch(
            ContentTypeEvents::REMOVE_CONTENT_TYPE_TRANSLATION,
            new RemoveContentTypeTranslationEvent($newContentTypeDraft, ...$eventData)
        );

        return $newContentTypeDraft;
    }
}


eZ/Publish/Core/Event/LanguageService.php 4 locations


        $this->eventDispatcher = $eventDispatcher;
    }

    public function createLanguage(LanguageCreateStruct $languageCreateStruct): Language
    {
        $eventData = [$languageCreateStruct];

        $beforeEvent = new BeforeCreateLanguageEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(LanguageEvents::BEFORE_CREATE_LANGUAGE, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $language = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::createLanguage($languageCreateStruct);

        $this->eventDispatcher->dispatch(
            LanguageEvents::CREATE_LANGUAGE,
            new CreateLanguageEvent($language, ...$eventData)
        );

        return $language;
    }

    public function updateLanguageName(
        Language $language,

        return $language;
    }

    public function updateLanguageName(
        Language $language,
        $newName
    ): Language {
        $eventData = [
            $language,
            $newName,
        ];

        $beforeEvent = new BeforeUpdateLanguageNameEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(LanguageEvents::BEFORE_UPDATE_LANGUAGE_NAME, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $updatedLanguage = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::updateLanguageName($language, $newName);

        $this->eventDispatcher->dispatch(
            LanguageEvents::UPDATE_LANGUAGE_NAME,
            new UpdateLanguageNameEvent($updatedLanguage, ...$eventData)
        );

        return $updatedLanguage;
    }

    public function enableLanguage(Language $language): Language
    {

        return $updatedLanguage;
    }

    public function enableLanguage(Language $language): Language
    {
        $eventData = [$language];

        $beforeEvent = new BeforeEnableLanguageEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(LanguageEvents::BEFORE_ENABLE_LANGUAGE, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $enabledLanguage = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::enableLanguage($language);

        $this->eventDispatcher->dispatch(
            LanguageEvents::ENABLE_LANGUAGE,
            new EnableLanguageEvent($enabledLanguage, ...$eventData)
        );

        return $enabledLanguage;
    }

    public function disableLanguage(Language $language): Language
    {

        return $enabledLanguage;
    }

    public function disableLanguage(Language $language): Language
    {
        $eventData = [$language];

        $beforeEvent = new BeforeDisableLanguageEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(LanguageEvents::BEFORE_DISABLE_LANGUAGE, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $disabledLanguage = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::disableLanguage($language);

        $this->eventDispatcher->dispatch(
            LanguageEvents::DISABLE_LANGUAGE,
            new DisableLanguageEvent($disabledLanguage, ...$eventData)
        );

        return $disabledLanguage;
    }

    public function deleteLanguage(Language $language): void
    {

eZ/Publish/Core/Event/LocationService.php 2 locations


        );
    }

    public function hideLocation(Location $location): Location
    {
        $eventData = [$location];

        $beforeEvent = new BeforeHideLocationEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(LocationEvents::BEFORE_HIDE_LOCATION, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $hiddenLocation = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::hideLocation($location);

        $this->eventDispatcher->dispatch(
            LocationEvents::HIDE_LOCATION,
            new HideLocationEvent($hiddenLocation, ...$eventData)
        );

        return $hiddenLocation;
    }

    public function unhideLocation(Location $location): Location
    {

        return $hiddenLocation;
    }

    public function unhideLocation(Location $location): Location
    {
        $eventData = [$location];

        $beforeEvent = new BeforeUnhideLocationEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(LocationEvents::BEFORE_UNHIDE_LOCATION, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $revealedLocation = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::unhideLocation($location);

        $this->eventDispatcher->dispatch(
            LocationEvents::UNHIDE_LOCATION,
            new UnhideLocationEvent($revealedLocation, ...$eventData)
        );

        return $revealedLocation;
    }

    public function moveSubtree(
        Location $location,

eZ/Publish/Core/Event/NotificationService.php 1 location


        );
    }

    public function createNotification(CreateStruct $createStruct): Notification
    {
        $eventData = [$createStruct];

        $beforeEvent = new BeforeCreateNotificationEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(NotificationEvents::BEFORE_CREATE_NOTIFICATION, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $notification = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::createNotification($createStruct);

        $this->eventDispatcher->dispatch(
            NotificationEvents::CREATE_NOTIFICATION,
            new CreateNotificationEvent($notification, ...$eventData)
        );

        return $notification;
    }

    public function deleteNotification(Notification $notification): void
    {

eZ/Publish/Core/Event/ObjectStateService.php 1 location


        $this->eventDispatcher = $eventDispatcher;
    }

    public function createObjectStateGroup(ObjectStateGroupCreateStruct $objectStateGroupCreateStruct): ObjectStateGroup
    {
        $eventData = [$objectStateGroupCreateStruct];

        $beforeEvent = new BeforeCreateObjectStateGroupEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(ObjectStateEvents::BEFORE_CREATE_OBJECT_STATE_GROUP, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $objectStateGroup = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::createObjectStateGroup($objectStateGroupCreateStruct);

        $this->eventDispatcher->dispatch(
            ObjectStateEvents::CREATE_OBJECT_STATE_GROUP,
            new CreateObjectStateGroupEvent($objectStateGroup, ...$eventData)
        );

        return $objectStateGroup;
    }

    public function updateObjectStateGroup(
        ObjectStateGroup $objectStateGroup,

eZ/Publish/Core/Event/RoleService.php 8 locations


        $this->eventDispatcher = $eventDispatcher;
    }

    public function createRole(RoleCreateStruct $roleCreateStruct): RoleDraft
    {
        $eventData = [$roleCreateStruct];

        $beforeEvent = new BeforeCreateRoleEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_CREATE_ROLE, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $roleDraft = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::createRole($roleCreateStruct);

        $this->eventDispatcher->dispatch(
            RoleEvents::CREATE_ROLE,
            new CreateRoleEvent($roleDraft, ...$eventData)
        );

        return $roleDraft;
    }

    public function createRoleDraft(Role $role)
    {

        return $roleDraft;
    }

    public function createRoleDraft(Role $role)
    {
        $eventData = [$role];

        $beforeEvent = new BeforeCreateRoleDraftEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_CREATE_ROLE_DRAFT, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $roleDraft = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::createRoleDraft($role);

        $this->eventDispatcher->dispatch(
            RoleEvents::CREATE_ROLE_DRAFT,
            new CreateRoleDraftEvent($roleDraft, ...$eventData)
        );

        return $roleDraft;
    }

    public function updateRoleDraft(
        RoleDraft $roleDraft,

        return $roleDraft;
    }

    public function updateRoleDraft(
        RoleDraft $roleDraft,
        RoleUpdateStruct $roleUpdateStruct
    ) {
        $eventData = [
            $roleDraft,
            $roleUpdateStruct,
        ];

        $beforeEvent = new BeforeUpdateRoleDraftEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_UPDATE_ROLE_DRAFT, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $updatedRoleDraft = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::updateRoleDraft($roleDraft, $roleUpdateStruct);

        $this->eventDispatcher->dispatch(
            RoleEvents::UPDATE_ROLE_DRAFT,
            new UpdateRoleDraftEvent($updatedRoleDraft, ...$eventData)
        );

        return $updatedRoleDraft;
    }

    public function addPolicyByRoleDraft(
        RoleDraft $roleDraft,

        return $updatedRoleDraft;
    }

    public function addPolicyByRoleDraft(
        RoleDraft $roleDraft,
        PolicyCreateStruct $policyCreateStruct
    ) {
        $eventData = [
            $roleDraft,
            $policyCreateStruct,
        ];

        $beforeEvent = new BeforeAddPolicyByRoleDraftEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_ADD_POLICY_BY_ROLE_DRAFT, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $updatedRoleDraft = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::addPolicyByRoleDraft($roleDraft, $policyCreateStruct);

        $this->eventDispatcher->dispatch(
            RoleEvents::ADD_POLICY_BY_ROLE_DRAFT,
            new AddPolicyByRoleDraftEvent($updatedRoleDraft, ...$eventData)
        );

        return $updatedRoleDraft;
    }

    public function removePolicyByRoleDraft(
        RoleDraft $roleDraft,

        return $updatedRoleDraft;
    }

    public function removePolicyByRoleDraft(
        RoleDraft $roleDraft,
        PolicyDraft $policyDraft
    ) {
        $eventData = [
            $roleDraft,
            $policyDraft,
        ];

        $beforeEvent = new BeforeRemovePolicyByRoleDraftEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_REMOVE_POLICY_BY_ROLE_DRAFT, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $updatedRoleDraft = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::removePolicyByRoleDraft($roleDraft, $policyDraft);

        $this->eventDispatcher->dispatch(
            RoleEvents::REMOVE_POLICY_BY_ROLE_DRAFT,
            new RemovePolicyByRoleDraftEvent($updatedRoleDraft, ...$eventData)
        );

        return $updatedRoleDraft;
    }

    public function updatePolicyByRoleDraft(
        RoleDraft $roleDraft,

        );
    }

    public function updateRole(
        Role $role,
        RoleUpdateStruct $roleUpdateStruct
    ) {
        $eventData = [
            $role,
            $roleUpdateStruct,
        ];

        $beforeEvent = new BeforeUpdateRoleEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_UPDATE_ROLE, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $updatedRole = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::updateRole($role, $roleUpdateStruct);

        $this->eventDispatcher->dispatch(
            RoleEvents::UPDATE_ROLE,
            new UpdateRoleEvent($updatedRole, ...$eventData)
        );

        return $updatedRole;
    }

    public function addPolicy(
        Role $role,

        return $updatedRole;
    }

    public function addPolicy(
        Role $role,
        PolicyCreateStruct $policyCreateStruct
    ) {
        $eventData = [
            $role,
            $policyCreateStruct,
        ];

        $beforeEvent = new BeforeAddPolicyEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_ADD_POLICY, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $updatedRole = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::addPolicy($role, $policyCreateStruct);

        $this->eventDispatcher->dispatch(
            RoleEvents::ADD_POLICY,
            new AddPolicyEvent($updatedRole, ...$eventData)
        );

        return $updatedRole;
    }

    public function deletePolicy(Policy $policy)
    {

        );
    }

    public function updatePolicy(
        Policy $policy,
        PolicyUpdateStruct $policyUpdateStruct
    ) {
        $eventData = [
            $policy,
            $policyUpdateStruct,
        ];

        $beforeEvent = new BeforeUpdatePolicyEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_UPDATE_POLICY, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $updatedPolicy = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::updatePolicy($policy, $policyUpdateStruct);

        $this->eventDispatcher->dispatch(
            RoleEvents::UPDATE_POLICY,
            new UpdatePolicyEvent($updatedPolicy, ...$eventData)
        );

        return $updatedPolicy;
    }

    public function deleteRole(Role $role)
    {

eZ/Publish/Core/Event/SectionService.php 2 locations


        $this->eventDispatcher = $eventDispatcher;
    }

    public function createSection(SectionCreateStruct $sectionCreateStruct)
    {
        $eventData = [$sectionCreateStruct];

        $beforeEvent = new BeforeCreateSectionEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(SectionEvents::BEFORE_CREATE_SECTION, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $section = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::createSection($sectionCreateStruct);

        $this->eventDispatcher->dispatch(
            SectionEvents::CREATE_SECTION,
            new CreateSectionEvent($section, ...$eventData)
        );

        return $section;
    }

    public function updateSection(
        Section $section,

        return $section;
    }

    public function updateSection(
        Section $section,
        SectionUpdateStruct $sectionUpdateStruct
    ) {
        $eventData = [
            $section,
            $sectionUpdateStruct,
        ];

        $beforeEvent = new BeforeUpdateSectionEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(SectionEvents::BEFORE_UPDATE_SECTION, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $updatedSection = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::updateSection($section, $sectionUpdateStruct);

        $this->eventDispatcher->dispatch(
            SectionEvents::UPDATE_SECTION,
            new UpdateSectionEvent($updatedSection, ...$eventData)
        );

        return $updatedSection;
    }

    public function assignSection(
        ContentInfo $contentInfo,

eZ/Publish/Core/Event/TrashService.php 2 locations


        $this->eventDispatcher = $eventDispatcher;
    }

    public function trash(Location $location)
    {
        $eventData = [$location];

        $beforeEvent = new BeforeTrashEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(TrashEvents::BEFORE_TRASH, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $trashItem = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::trash($location);

        $this->eventDispatcher->dispatch(
            TrashEvents::TRASH,
            new TrashEvent($trashItem, ...$eventData)
        );

        return $trashItem;
    }

    public function recover(
        TrashItem $trashItem,

        return $resultList;
    }

    public function deleteTrashItem(TrashItem $trashItem)
    {
        $eventData = [$trashItem];

        $beforeEvent = new BeforeDeleteTrashItemEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(TrashEvents::BEFORE_DELETE_TRASH_ITEM, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $result = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::deleteTrashItem($trashItem);

        $this->eventDispatcher->dispatch(
            TrashEvents::DELETE_TRASH_ITEM,
            new DeleteTrashItemEvent($result, ...$eventData)
        );

        return $result;
    }
}


eZ/Publish/Core/Event/URLService.php 1 location


        $this->eventDispatcher = $eventDispatcher;
    }

    public function updateUrl(
        URL $url,
        URLUpdateStruct $struct
    ) {
        $eventData = [
            $url,
            $struct,
        ];

        $beforeEvent = new BeforeUpdateUrlEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(URLEvents::BEFORE_UPDATE_URL, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $updatedUrl = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::updateUrl($url, $struct);

        $this->eventDispatcher->dispatch(
            URLEvents::UPDATE_URL,
            new UpdateUrlEvent($updatedUrl, ...$eventData)
        );

        return $updatedUrl;
    }
}


eZ/Publish/Core/Event/URLWildcardService.php 1 location


        );
    }

    public function translate($url)
    {
        $eventData = [$url];

        $beforeEvent = new BeforeTranslateEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(URLWildcardEvents::BEFORE_TRANSLATE, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $result = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::translate($url);

        $this->eventDispatcher->dispatch(
            URLWildcardEvents::TRANSLATE,
            new TranslateEvent($result, ...$eventData)
        );

        return $result;
    }
}


eZ/Publish/Core/Event/UserService.php 7 locations


        $this->eventDispatcher = $eventDispatcher;
    }

    public function createUserGroup(
        UserGroupCreateStruct $userGroupCreateStruct,
        UserGroup $parentGroup
    ) {
        $eventData = [
            $userGroupCreateStruct,
            $parentGroup,
        ];

        $beforeEvent = new BeforeCreateUserGroupEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(UserEvents::BEFORE_CREATE_USER_GROUP, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $userGroup = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::createUserGroup($userGroupCreateStruct, $parentGroup);

        $this->eventDispatcher->dispatch(
            UserEvents::CREATE_USER_GROUP,
            new CreateUserGroupEvent($userGroup, ...$eventData)
        );

        return $userGroup;
    }

    public function deleteUserGroup(UserGroup $userGroup)
    {

        return $userGroup;
    }

    public function deleteUserGroup(UserGroup $userGroup)
    {
        $eventData = [$userGroup];

        $beforeEvent = new BeforeDeleteUserGroupEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(UserEvents::BEFORE_DELETE_USER_GROUP, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $locations = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::deleteUserGroup($userGroup);

        $this->eventDispatcher->dispatch(
            UserEvents::DELETE_USER_GROUP,
            new DeleteUserGroupEvent($locations, ...$eventData)
        );

        return $locations;
    }

    public function moveUserGroup(
        UserGroup $userGroup,

        );
    }

    public function updateUserGroup(
        UserGroup $userGroup,
        UserGroupUpdateStruct $userGroupUpdateStruct
    ) {
        $eventData = [
            $userGroup,
            $userGroupUpdateStruct,
        ];

        $beforeEvent = new BeforeUpdateUserGroupEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(UserEvents::BEFORE_UPDATE_USER_GROUP, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $updatedUserGroup = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::updateUserGroup($userGroup, $userGroupUpdateStruct);

        $this->eventDispatcher->dispatch(
            UserEvents::UPDATE_USER_GROUP,
            new UpdateUserGroupEvent($updatedUserGroup, ...$eventData)
        );

        return $updatedUserGroup;
    }

    public function createUser(
        UserCreateStruct $userCreateStruct,

        return $updatedUserGroup;
    }

    public function createUser(
        UserCreateStruct $userCreateStruct,
        array $parentGroups
    ) {
        $eventData = [
            $userCreateStruct,
            $parentGroups,
        ];

        $beforeEvent = new BeforeCreateUserEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(UserEvents::BEFORE_CREATE_USER, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $user = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::createUser($userCreateStruct, $parentGroups);

        $this->eventDispatcher->dispatch(
            UserEvents::CREATE_USER,
            new CreateUserEvent($user, ...$eventData)
        );

        return $user;
    }

    public function deleteUser(User $user)
    {

        return $user;
    }

    public function deleteUser(User $user)
    {
        $eventData = [$user];

        $beforeEvent = new BeforeDeleteUserEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(UserEvents::BEFORE_DELETE_USER, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $locations = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::deleteUser($user);

        $this->eventDispatcher->dispatch(
            UserEvents::DELETE_USER,
            new DeleteUserEvent($locations, ...$eventData)
        );

        return $locations;
    }

    public function updateUser(
        User $user,

        return $locations;
    }

    public function updateUser(
        User $user,
        UserUpdateStruct $userUpdateStruct
    ) {
        $eventData = [
            $user,
            $userUpdateStruct,
        ];

        $beforeEvent = new BeforeUpdateUserEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(UserEvents::BEFORE_UPDATE_USER, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $updatedUser = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::updateUser($user, $userUpdateStruct);

        $this->eventDispatcher->dispatch(
            UserEvents::UPDATE_USER,
            new UpdateUserEvent($updatedUser, ...$eventData)
        );

        return $updatedUser;
    }

    public function updateUserToken(
        User $user,

        return $updatedUser;
    }

    public function updateUserToken(
        User $user,
        UserTokenUpdateStruct $userTokenUpdateStruct
    ) {
        $eventData = [
            $user,
            $userTokenUpdateStruct,
        ];

        $beforeEvent = new BeforeUpdateUserTokenEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(UserEvents::BEFORE_UPDATE_USER_TOKEN, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $updatedUser = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::updateUserToken($user, $userTokenUpdateStruct);

        $this->eventDispatcher->dispatch(
            UserEvents::UPDATE_USER_TOKEN,
            new UpdateUserTokenEvent($updatedUser, ...$eventData)
        );

        return $updatedUser;
    }

    public function assignUserToUserGroup(
        User $user,

		@@ 119-138 (lines=20) @@
116		return $content;
117		}
118
119		public function deleteContent(ContentInfo $contentInfo): array
120		{
121		$eventData = [$contentInfo];
122
123		$beforeEvent = new BeforeDeleteContentEvent(...$eventData);
124		if ($this->eventDispatcher->dispatch(ContentEvents::BEFORE_DELETE_CONTENT, $beforeEvent)->isPropagationStopped()) {
125		return $beforeEvent->getReturnValue();
126		}
127
128		$locations = $beforeEvent->hasReturnValue()
129		? $beforeEvent->getReturnValue()
130		: parent::deleteContent($contentInfo);
131
132		$this->eventDispatcher->dispatch(
133		ContentEvents::DELETE_CONTENT,
134		new DeleteContentEvent($locations, ...$eventData)
135		);
136
137		return $locations;
138		}
139
140		public function createContentDraft(
141		ContentInfo $contentInfo,
		@@ 194-213 (lines=20) @@
191		return $content;
192		}
193
194		public function publishVersion(VersionInfo $versionInfo): Content
195		{
196		$eventData = [$versionInfo];
197
198		$beforeEvent = new BeforePublishVersionEvent(...$eventData);
199		if ($this->eventDispatcher->dispatch(ContentEvents::BEFORE_PUBLISH_VERSION, $beforeEvent)->isPropagationStopped()) {
200		return $beforeEvent->getReturnValue();
201		}
202
203		$content = $beforeEvent->hasReturnValue()
204		? $beforeEvent->getReturnValue()
205		: parent::publishVersion($versionInfo);
206
207		$this->eventDispatcher->dispatch(
208		ContentEvents::PUBLISH_VERSION,
209		new PublishVersionEvent($content, ...$eventData)
210		);
211
212		return $content;
213		}
214
215		public function deleteVersion(VersionInfo $versionInfo): void
216		{

		@@ 73-92 (lines=20) @@
70		$this->eventDispatcher = $eventDispatcher;
71		}
72
73		public function createContentTypeGroup(ContentTypeGroupCreateStruct $contentTypeGroupCreateStruct)
74		{
75		$eventData = [$contentTypeGroupCreateStruct];
76
77		$beforeEvent = new BeforeCreateContentTypeGroupEvent(...$eventData);
78		if ($this->eventDispatcher->dispatch(ContentTypeEvents::BEFORE_CREATE_CONTENT_TYPE_GROUP, $beforeEvent)->isPropagationStopped()) {
79		return $beforeEvent->getReturnValue();
80		}
81
82		$contentTypeGroup = $beforeEvent->hasReturnValue()
83		? $beforeEvent->getReturnValue()
84		: parent::createContentTypeGroup($contentTypeGroupCreateStruct);
85
86		$this->eventDispatcher->dispatch(
87		ContentTypeEvents::CREATE_CONTENT_TYPE_GROUP,
88		new CreateContentTypeGroupEvent($contentTypeGroup, ...$eventData)
89		);
90
91		return $contentTypeGroup;
92		}
93
94		public function updateContentTypeGroup(
95		ContentTypeGroup $contentTypeGroup,
		@@ 133-157 (lines=25) @@
130		);
131		}
132
133		public function createContentType(
134		ContentTypeCreateStruct $contentTypeCreateStruct,
135		array $contentTypeGroups
136		) {
137		$eventData = [
138		$contentTypeCreateStruct,
139		$contentTypeGroups,
140		];
141
142		$beforeEvent = new BeforeCreateContentTypeEvent(...$eventData);
143		if ($this->eventDispatcher->dispatch(ContentTypeEvents::BEFORE_CREATE_CONTENT_TYPE, $beforeEvent)->isPropagationStopped()) {
144		return $beforeEvent->getReturnValue();
145		}
146
147		$contentTypeDraft = $beforeEvent->hasReturnValue()
148		? $beforeEvent->getReturnValue()
149		: parent::createContentType($contentTypeCreateStruct, $contentTypeGroups);
150
151		$this->eventDispatcher->dispatch(
152		ContentTypeEvents::CREATE_CONTENT_TYPE,
153		new CreateContentTypeEvent($contentTypeDraft, ...$eventData)
154		);
155
156		return $contentTypeDraft;
157		}
158
159		public function createContentTypeDraft(ContentType $contentType)
160		{
		@@ 159-178 (lines=20) @@
156		return $contentTypeDraft;
157		}
158
159		public function createContentTypeDraft(ContentType $contentType)
160		{
161		$eventData = [$contentType];
162
163		$beforeEvent = new BeforeCreateContentTypeDraftEvent(...$eventData);
164		if ($this->eventDispatcher->dispatch(ContentTypeEvents::BEFORE_CREATE_CONTENT_TYPE_DRAFT, $beforeEvent)->isPropagationStopped()) {
165		return $beforeEvent->getReturnValue();
166		}
167
168		$contentTypeDraft = $beforeEvent->hasReturnValue()
169		? $beforeEvent->getReturnValue()
170		: parent::createContentTypeDraft($contentType);
171
172		$this->eventDispatcher->dispatch(
173		ContentTypeEvents::CREATE_CONTENT_TYPE_DRAFT,
174		new CreateContentTypeDraftEvent($contentTypeDraft, ...$eventData)
175		);
176
177		return $contentTypeDraft;
178		}
179
180		public function updateContentTypeDraft(
181		ContentTypeDraft $contentTypeDraft,
		@@ 374-398 (lines=25) @@
371		);
372		}
373
374		public function removeContentTypeTranslation(
375		ContentTypeDraft $contentTypeDraft,
376		string $languageCode
377		): ContentTypeDraft {
378		$eventData = [
379		$contentTypeDraft,
380		$languageCode,
381		];
382
383		$beforeEvent = new BeforeRemoveContentTypeTranslationEvent(...$eventData);
384		if ($this->eventDispatcher->dispatch(ContentTypeEvents::BEFORE_REMOVE_CONTENT_TYPE_TRANSLATION, $beforeEvent)->isPropagationStopped()) {
385		return $beforeEvent->getReturnValue();
386		}
387
388		$newContentTypeDraft = $beforeEvent->hasReturnValue()
389		? $beforeEvent->getReturnValue()
390		: parent::removeContentTypeTranslation($contentTypeDraft, $languageCode);
391
392		$this->eventDispatcher->dispatch(
393		ContentTypeEvents::REMOVE_CONTENT_TYPE_TRANSLATION,
394		new RemoveContentTypeTranslationEvent($newContentTypeDraft, ...$eventData)
395		);
396
397		return $newContentTypeDraft;
398		}
399		}
400

		@@ 44-63 (lines=20) @@
41		$this->eventDispatcher = $eventDispatcher;
42		}
43
44		public function createLanguage(LanguageCreateStruct $languageCreateStruct): Language
45		{
46		$eventData = [$languageCreateStruct];
47
48		$beforeEvent = new BeforeCreateLanguageEvent(...$eventData);
49		if ($this->eventDispatcher->dispatch(LanguageEvents::BEFORE_CREATE_LANGUAGE, $beforeEvent)->isPropagationStopped()) {
50		return $beforeEvent->getReturnValue();
51		}
52
53		$language = $beforeEvent->hasReturnValue()
54		? $beforeEvent->getReturnValue()
55		: parent::createLanguage($languageCreateStruct);
56
57		$this->eventDispatcher->dispatch(
58		LanguageEvents::CREATE_LANGUAGE,
59		new CreateLanguageEvent($language, ...$eventData)
60		);
61
62		return $language;
63		}
64
65		public function updateLanguageName(
66		Language $language,
		@@ 65-89 (lines=25) @@
62		return $language;
63		}
64
65		public function updateLanguageName(
66		Language $language,
67		$newName
68		): Language {
69		$eventData = [
70		$language,
71		$newName,
72		];
73
74		$beforeEvent = new BeforeUpdateLanguageNameEvent(...$eventData);
75		if ($this->eventDispatcher->dispatch(LanguageEvents::BEFORE_UPDATE_LANGUAGE_NAME, $beforeEvent)->isPropagationStopped()) {
76		return $beforeEvent->getReturnValue();
77		}
78
79		$updatedLanguage = $beforeEvent->hasReturnValue()
80		? $beforeEvent->getReturnValue()
81		: parent::updateLanguageName($language, $newName);
82
83		$this->eventDispatcher->dispatch(
84		LanguageEvents::UPDATE_LANGUAGE_NAME,
85		new UpdateLanguageNameEvent($updatedLanguage, ...$eventData)
86		);
87
88		return $updatedLanguage;
89		}
90
91		public function enableLanguage(Language $language): Language
92		{
		@@ 91-110 (lines=20) @@
88		return $updatedLanguage;
89		}
90
91		public function enableLanguage(Language $language): Language
92		{
93		$eventData = [$language];
94
95		$beforeEvent = new BeforeEnableLanguageEvent(...$eventData);
96		if ($this->eventDispatcher->dispatch(LanguageEvents::BEFORE_ENABLE_LANGUAGE, $beforeEvent)->isPropagationStopped()) {
97		return $beforeEvent->getReturnValue();
98		}
99
100		$enabledLanguage = $beforeEvent->hasReturnValue()
101		? $beforeEvent->getReturnValue()
102		: parent::enableLanguage($language);
103
104		$this->eventDispatcher->dispatch(
105		LanguageEvents::ENABLE_LANGUAGE,
106		new EnableLanguageEvent($enabledLanguage, ...$eventData)
107		);
108
109		return $enabledLanguage;
110		}
111
112		public function disableLanguage(Language $language): Language
113		{
		@@ 112-131 (lines=20) @@
109		return $enabledLanguage;
110		}
111
112		public function disableLanguage(Language $language): Language
113		{
114		$eventData = [$language];
115
116		$beforeEvent = new BeforeDisableLanguageEvent(...$eventData);
117		if ($this->eventDispatcher->dispatch(LanguageEvents::BEFORE_DISABLE_LANGUAGE, $beforeEvent)->isPropagationStopped()) {
118		return $beforeEvent->getReturnValue();
119		}
120
121		$disabledLanguage = $beforeEvent->hasReturnValue()
122		? $beforeEvent->getReturnValue()
123		: parent::disableLanguage($language);
124
125		$this->eventDispatcher->dispatch(
126		LanguageEvents::DISABLE_LANGUAGE,
127		new DisableLanguageEvent($disabledLanguage, ...$eventData)
128		);
129
130		return $disabledLanguage;
131		}
132
133		public function deleteLanguage(Language $language): void
134		{

		@@ 152-171 (lines=20) @@
149		);
150		}
151
152		public function hideLocation(Location $location): Location
153		{
154		$eventData = [$location];
155
156		$beforeEvent = new BeforeHideLocationEvent(...$eventData);
157		if ($this->eventDispatcher->dispatch(LocationEvents::BEFORE_HIDE_LOCATION, $beforeEvent)->isPropagationStopped()) {
158		return $beforeEvent->getReturnValue();
159		}
160
161		$hiddenLocation = $beforeEvent->hasReturnValue()
162		? $beforeEvent->getReturnValue()
163		: parent::hideLocation($location);
164
165		$this->eventDispatcher->dispatch(
166		LocationEvents::HIDE_LOCATION,
167		new HideLocationEvent($hiddenLocation, ...$eventData)
168		);
169
170		return $hiddenLocation;
171		}
172
173		public function unhideLocation(Location $location): Location
174		{
		@@ 173-192 (lines=20) @@
170		return $hiddenLocation;
171		}
172
173		public function unhideLocation(Location $location): Location
174		{
175		$eventData = [$location];
176
177		$beforeEvent = new BeforeUnhideLocationEvent(...$eventData);
178		if ($this->eventDispatcher->dispatch(LocationEvents::BEFORE_UNHIDE_LOCATION, $beforeEvent)->isPropagationStopped()) {
179		return $beforeEvent->getReturnValue();
180		}
181
182		$revealedLocation = $beforeEvent->hasReturnValue()
183		? $beforeEvent->getReturnValue()
184		: parent::unhideLocation($location);
185
186		$this->eventDispatcher->dispatch(
187		LocationEvents::UNHIDE_LOCATION,
188		new UnhideLocationEvent($revealedLocation, ...$eventData)
189		);
190
191		return $revealedLocation;
192		}
193
194		public function moveSubtree(
195		Location $location,

		@@ 57-76 (lines=20) @@
54		);
55		}
56
57		public function createNotification(CreateStruct $createStruct): Notification
58		{
59		$eventData = [$createStruct];
60
61		$beforeEvent = new BeforeCreateNotificationEvent(...$eventData);
62		if ($this->eventDispatcher->dispatch(NotificationEvents::BEFORE_CREATE_NOTIFICATION, $beforeEvent)->isPropagationStopped()) {
63		return $beforeEvent->getReturnValue();
64		}
65
66		$notification = $beforeEvent->hasReturnValue()
67		? $beforeEvent->getReturnValue()
68		: parent::createNotification($createStruct);
69
70		$this->eventDispatcher->dispatch(
71		NotificationEvents::CREATE_NOTIFICATION,
72		new CreateNotificationEvent($notification, ...$eventData)
73		);
74
75		return $notification;
76		}
77
78		public function deleteNotification(Notification $notification): void
79		{

		@@ 55-74 (lines=20) @@
52		$this->eventDispatcher = $eventDispatcher;
53		}
54
55		public function createObjectStateGroup(ObjectStateGroupCreateStruct $objectStateGroupCreateStruct): ObjectStateGroup
56		{
57		$eventData = [$objectStateGroupCreateStruct];
58
59		$beforeEvent = new BeforeCreateObjectStateGroupEvent(...$eventData);
60		if ($this->eventDispatcher->dispatch(ObjectStateEvents::BEFORE_CREATE_OBJECT_STATE_GROUP, $beforeEvent)->isPropagationStopped()) {
61		return $beforeEvent->getReturnValue();
62		}
63
64		$objectStateGroup = $beforeEvent->hasReturnValue()
65		? $beforeEvent->getReturnValue()
66		: parent::createObjectStateGroup($objectStateGroupCreateStruct);
67
68		$this->eventDispatcher->dispatch(
69		ObjectStateEvents::CREATE_OBJECT_STATE_GROUP,
70		new CreateObjectStateGroupEvent($objectStateGroup, ...$eventData)
71		);
72
73		return $objectStateGroup;
74		}
75
76		public function updateObjectStateGroup(
77		ObjectStateGroup $objectStateGroup,

		@@ 80-99 (lines=20) @@
77		$this->eventDispatcher = $eventDispatcher;
78		}
79
80		public function createRole(RoleCreateStruct $roleCreateStruct): RoleDraft
81		{
82		$eventData = [$roleCreateStruct];
83
84		$beforeEvent = new BeforeCreateRoleEvent(...$eventData);
85		if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_CREATE_ROLE, $beforeEvent)->isPropagationStopped()) {
86		return $beforeEvent->getReturnValue();
87		}
88
89		$roleDraft = $beforeEvent->hasReturnValue()
90		? $beforeEvent->getReturnValue()
91		: parent::createRole($roleCreateStruct);
92
93		$this->eventDispatcher->dispatch(
94		RoleEvents::CREATE_ROLE,
95		new CreateRoleEvent($roleDraft, ...$eventData)
96		);
97
98		return $roleDraft;
99		}
100
101		public function createRoleDraft(Role $role)
102		{
		@@ 101-120 (lines=20) @@
98		return $roleDraft;
99		}
100
101		public function createRoleDraft(Role $role)
102		{
103		$eventData = [$role];
104
105		$beforeEvent = new BeforeCreateRoleDraftEvent(...$eventData);
106		if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_CREATE_ROLE_DRAFT, $beforeEvent)->isPropagationStopped()) {
107		return $beforeEvent->getReturnValue();
108		}
109
110		$roleDraft = $beforeEvent->hasReturnValue()
111		? $beforeEvent->getReturnValue()
112		: parent::createRoleDraft($role);
113
114		$this->eventDispatcher->dispatch(
115		RoleEvents::CREATE_ROLE_DRAFT,
116		new CreateRoleDraftEvent($roleDraft, ...$eventData)
117		);
118
119		return $roleDraft;
120		}
121
122		public function updateRoleDraft(
123		RoleDraft $roleDraft,
		@@ 122-146 (lines=25) @@
119		return $roleDraft;
120		}
121
122		public function updateRoleDraft(
123		RoleDraft $roleDraft,
124		RoleUpdateStruct $roleUpdateStruct
125		) {
126		$eventData = [
127		$roleDraft,
128		$roleUpdateStruct,
129		];
130
131		$beforeEvent = new BeforeUpdateRoleDraftEvent(...$eventData);
132		if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_UPDATE_ROLE_DRAFT, $beforeEvent)->isPropagationStopped()) {
133		return $beforeEvent->getReturnValue();
134		}
135
136		$updatedRoleDraft = $beforeEvent->hasReturnValue()
137		? $beforeEvent->getReturnValue()
138		: parent::updateRoleDraft($roleDraft, $roleUpdateStruct);
139
140		$this->eventDispatcher->dispatch(
141		RoleEvents::UPDATE_ROLE_DRAFT,
142		new UpdateRoleDraftEvent($updatedRoleDraft, ...$eventData)
143		);
144
145		return $updatedRoleDraft;
146		}
147
148		public function addPolicyByRoleDraft(
149		RoleDraft $roleDraft,
		@@ 148-172 (lines=25) @@
145		return $updatedRoleDraft;
146		}
147
148		public function addPolicyByRoleDraft(
149		RoleDraft $roleDraft,
150		PolicyCreateStruct $policyCreateStruct
151		) {
152		$eventData = [
153		$roleDraft,
154		$policyCreateStruct,
155		];
156
157		$beforeEvent = new BeforeAddPolicyByRoleDraftEvent(...$eventData);
158		if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_ADD_POLICY_BY_ROLE_DRAFT, $beforeEvent)->isPropagationStopped()) {
159		return $beforeEvent->getReturnValue();
160		}
161
162		$updatedRoleDraft = $beforeEvent->hasReturnValue()
163		? $beforeEvent->getReturnValue()
164		: parent::addPolicyByRoleDraft($roleDraft, $policyCreateStruct);
165
166		$this->eventDispatcher->dispatch(
167		RoleEvents::ADD_POLICY_BY_ROLE_DRAFT,
168		new AddPolicyByRoleDraftEvent($updatedRoleDraft, ...$eventData)
169		);
170
171		return $updatedRoleDraft;
172		}
173
174		public function removePolicyByRoleDraft(
175		RoleDraft $roleDraft,
		@@ 174-198 (lines=25) @@
171		return $updatedRoleDraft;
172		}
173
174		public function removePolicyByRoleDraft(
175		RoleDraft $roleDraft,
176		PolicyDraft $policyDraft
177		) {
178		$eventData = [
179		$roleDraft,
180		$policyDraft,
181		];
182
183		$beforeEvent = new BeforeRemovePolicyByRoleDraftEvent(...$eventData);
184		if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_REMOVE_POLICY_BY_ROLE_DRAFT, $beforeEvent)->isPropagationStopped()) {
185		return $beforeEvent->getReturnValue();
186		}
187
188		$updatedRoleDraft = $beforeEvent->hasReturnValue()
189		? $beforeEvent->getReturnValue()
190		: parent::removePolicyByRoleDraft($roleDraft, $policyDraft);
191
192		$this->eventDispatcher->dispatch(
193		RoleEvents::REMOVE_POLICY_BY_ROLE_DRAFT,
194		new RemovePolicyByRoleDraftEvent($updatedRoleDraft, ...$eventData)
195		);
196
197		return $updatedRoleDraft;
198		}
199
200		public function updatePolicyByRoleDraft(
201		RoleDraft $roleDraft,
		@@ 262-286 (lines=25) @@
259		);
260		}
261
262		public function updateRole(
263		Role $role,
264		RoleUpdateStruct $roleUpdateStruct
265		) {
266		$eventData = [
267		$role,
268		$roleUpdateStruct,
269		];
270
271		$beforeEvent = new BeforeUpdateRoleEvent(...$eventData);
272		if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_UPDATE_ROLE, $beforeEvent)->isPropagationStopped()) {
273		return $beforeEvent->getReturnValue();
274		}
275
276		$updatedRole = $beforeEvent->hasReturnValue()
277		? $beforeEvent->getReturnValue()
278		: parent::updateRole($role, $roleUpdateStruct);
279
280		$this->eventDispatcher->dispatch(
281		RoleEvents::UPDATE_ROLE,
282		new UpdateRoleEvent($updatedRole, ...$eventData)
283		);
284
285		return $updatedRole;
286		}
287
288		public function addPolicy(
289		Role $role,
		@@ 288-312 (lines=25) @@
285		return $updatedRole;
286		}
287
288		public function addPolicy(
289		Role $role,
290		PolicyCreateStruct $policyCreateStruct
291		) {
292		$eventData = [
293		$role,
294		$policyCreateStruct,
295		];
296
297		$beforeEvent = new BeforeAddPolicyEvent(...$eventData);
298		if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_ADD_POLICY, $beforeEvent)->isPropagationStopped()) {
299		return $beforeEvent->getReturnValue();
300		}
301
302		$updatedRole = $beforeEvent->hasReturnValue()
303		? $beforeEvent->getReturnValue()
304		: parent::addPolicy($role, $policyCreateStruct);
305
306		$this->eventDispatcher->dispatch(
307		RoleEvents::ADD_POLICY,
308		new AddPolicyEvent($updatedRole, ...$eventData)
309		);
310
311		return $updatedRole;
312		}
313
314		public function deletePolicy(Policy $policy)
315		{
		@@ 331-355 (lines=25) @@
328		);
329		}
330
331		public function updatePolicy(
332		Policy $policy,
333		PolicyUpdateStruct $policyUpdateStruct
334		) {
335		$eventData = [
336		$policy,
337		$policyUpdateStruct,
338		];
339
340		$beforeEvent = new BeforeUpdatePolicyEvent(...$eventData);
341		if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_UPDATE_POLICY, $beforeEvent)->isPropagationStopped()) {
342		return $beforeEvent->getReturnValue();
343		}
344
345		$updatedPolicy = $beforeEvent->hasReturnValue()
346		? $beforeEvent->getReturnValue()
347		: parent::updatePolicy($policy, $policyUpdateStruct);
348
349		$this->eventDispatcher->dispatch(
350		RoleEvents::UPDATE_POLICY,
351		new UpdatePolicyEvent($updatedPolicy, ...$eventData)
352		);
353
354		return $updatedPolicy;
355		}
356
357		public function deleteRole(Role $role)
358		{

		@@ 47-66 (lines=20) @@
44		$this->eventDispatcher = $eventDispatcher;
45		}
46
47		public function createSection(SectionCreateStruct $sectionCreateStruct)
48		{
49		$eventData = [$sectionCreateStruct];
50
51		$beforeEvent = new BeforeCreateSectionEvent(...$eventData);
52		if ($this->eventDispatcher->dispatch(SectionEvents::BEFORE_CREATE_SECTION, $beforeEvent)->isPropagationStopped()) {
53		return $beforeEvent->getReturnValue();
54		}
55
56		$section = $beforeEvent->hasReturnValue()
57		? $beforeEvent->getReturnValue()
58		: parent::createSection($sectionCreateStruct);
59
60		$this->eventDispatcher->dispatch(
61		SectionEvents::CREATE_SECTION,
62		new CreateSectionEvent($section, ...$eventData)
63		);
64
65		return $section;
66		}
67
68		public function updateSection(
69		Section $section,
		@@ 68-92 (lines=25) @@
65		return $section;
66		}
67
68		public function updateSection(
69		Section $section,
70		SectionUpdateStruct $sectionUpdateStruct
71		) {
72		$eventData = [
73		$section,
74		$sectionUpdateStruct,
75		];
76
77		$beforeEvent = new BeforeUpdateSectionEvent(...$eventData);
78		if ($this->eventDispatcher->dispatch(SectionEvents::BEFORE_UPDATE_SECTION, $beforeEvent)->isPropagationStopped()) {
79		return $beforeEvent->getReturnValue();
80		}
81
82		$updatedSection = $beforeEvent->hasReturnValue()
83		? $beforeEvent->getReturnValue()
84		: parent::updateSection($section, $sectionUpdateStruct);
85
86		$this->eventDispatcher->dispatch(
87		SectionEvents::UPDATE_SECTION,
88		new UpdateSectionEvent($updatedSection, ...$eventData)
89		);
90
91		return $updatedSection;
92		}
93
94		public function assignSection(
95		ContentInfo $contentInfo,

		@@ 42-61 (lines=20) @@
39		$this->eventDispatcher = $eventDispatcher;
40		}
41
42		public function trash(Location $location)
43		{
44		$eventData = [$location];
45
46		$beforeEvent = new BeforeTrashEvent(...$eventData);
47		if ($this->eventDispatcher->dispatch(TrashEvents::BEFORE_TRASH, $beforeEvent)->isPropagationStopped()) {
48		return $beforeEvent->getReturnValue();
49		}
50
51		$trashItem = $beforeEvent->hasReturnValue()
52		? $beforeEvent->getReturnValue()
53		: parent::trash($location);
54
55		$this->eventDispatcher->dispatch(
56		TrashEvents::TRASH,
57		new TrashEvent($trashItem, ...$eventData)
58		);
59
60		return $trashItem;
61		}
62
63		public function recover(
64		TrashItem $trashItem,
		@@ 108-127 (lines=20) @@
105		return $resultList;
106		}
107
108		public function deleteTrashItem(TrashItem $trashItem)
109		{
110		$eventData = [$trashItem];
111
112		$beforeEvent = new BeforeDeleteTrashItemEvent(...$eventData);
113		if ($this->eventDispatcher->dispatch(TrashEvents::BEFORE_DELETE_TRASH_ITEM, $beforeEvent)->isPropagationStopped()) {
114		return $beforeEvent->getReturnValue();
115		}
116
117		$result = $beforeEvent->hasReturnValue()
118		? $beforeEvent->getReturnValue()
119		: parent::deleteTrashItem($trashItem);
120
121		$this->eventDispatcher->dispatch(
122		TrashEvents::DELETE_TRASH_ITEM,
123		new DeleteTrashItemEvent($result, ...$eventData)
124		);
125
126		return $result;
127		}
128		}
129

		@@ 36-60 (lines=25) @@
33		$this->eventDispatcher = $eventDispatcher;
34		}
35
36		public function updateUrl(
37		URL $url,
38		URLUpdateStruct $struct
39		) {
40		$eventData = [
41		$url,
42		$struct,
43		];
44
45		$beforeEvent = new BeforeUpdateUrlEvent(...$eventData);
46		if ($this->eventDispatcher->dispatch(URLEvents::BEFORE_UPDATE_URL, $beforeEvent)->isPropagationStopped()) {
47		return $beforeEvent->getReturnValue();
48		}
49
50		$updatedUrl = $beforeEvent->hasReturnValue()
51		? $beforeEvent->getReturnValue()
52		: parent::updateUrl($url, $struct);
53
54		$this->eventDispatcher->dispatch(
55		URLEvents::UPDATE_URL,
56		new UpdateUrlEvent($updatedUrl, ...$eventData)
57		);
58
59		return $updatedUrl;
60		}
61		}
62

		@@ 84-103 (lines=20) @@
81		);
82		}
83
84		public function translate($url)
85		{
86		$eventData = [$url];
87
88		$beforeEvent = new BeforeTranslateEvent(...$eventData);
89		if ($this->eventDispatcher->dispatch(URLWildcardEvents::BEFORE_TRANSLATE, $beforeEvent)->isPropagationStopped()) {
90		return $beforeEvent->getReturnValue();
91		}
92
93		$result = $beforeEvent->hasReturnValue()
94		? $beforeEvent->getReturnValue()
95		: parent::translate($url);
96
97		$this->eventDispatcher->dispatch(
98		URLWildcardEvents::TRANSLATE,
99		new TranslateEvent($result, ...$eventData)
100		);
101
102		return $result;
103		}
104		}
105

		@@ 59-83 (lines=25) @@
56		$this->eventDispatcher = $eventDispatcher;
57		}
58
59		public function createUserGroup(
60		UserGroupCreateStruct $userGroupCreateStruct,
61		UserGroup $parentGroup
62		) {
63		$eventData = [
64		$userGroupCreateStruct,
65		$parentGroup,
66		];
67
68		$beforeEvent = new BeforeCreateUserGroupEvent(...$eventData);
69		if ($this->eventDispatcher->dispatch(UserEvents::BEFORE_CREATE_USER_GROUP, $beforeEvent)->isPropagationStopped()) {
70		return $beforeEvent->getReturnValue();
71		}
72
73		$userGroup = $beforeEvent->hasReturnValue()
74		? $beforeEvent->getReturnValue()
75		: parent::createUserGroup($userGroupCreateStruct, $parentGroup);
76
77		$this->eventDispatcher->dispatch(
78		UserEvents::CREATE_USER_GROUP,
79		new CreateUserGroupEvent($userGroup, ...$eventData)
80		);
81
82		return $userGroup;
83		}
84
85		public function deleteUserGroup(UserGroup $userGroup)
86		{
		@@ 85-104 (lines=20) @@
82		return $userGroup;
83		}
84
85		public function deleteUserGroup(UserGroup $userGroup)
86		{
87		$eventData = [$userGroup];
88
89		$beforeEvent = new BeforeDeleteUserGroupEvent(...$eventData);
90		if ($this->eventDispatcher->dispatch(UserEvents::BEFORE_DELETE_USER_GROUP, $beforeEvent)->isPropagationStopped()) {
91		return $beforeEvent->getReturnValue();
92		}
93
94		$locations = $beforeEvent->hasReturnValue()
95		? $beforeEvent->getReturnValue()
96		: parent::deleteUserGroup($userGroup);
97
98		$this->eventDispatcher->dispatch(
99		UserEvents::DELETE_USER_GROUP,
100		new DeleteUserGroupEvent($locations, ...$eventData)
101		);
102
103		return $locations;
104		}
105
106		public function moveUserGroup(
107		UserGroup $userGroup,
		@@ 128-152 (lines=25) @@
125		);
126		}
127
128		public function updateUserGroup(
129		UserGroup $userGroup,
130		UserGroupUpdateStruct $userGroupUpdateStruct
131		) {
132		$eventData = [
133		$userGroup,
134		$userGroupUpdateStruct,
135		];
136
137		$beforeEvent = new BeforeUpdateUserGroupEvent(...$eventData);
138		if ($this->eventDispatcher->dispatch(UserEvents::BEFORE_UPDATE_USER_GROUP, $beforeEvent)->isPropagationStopped()) {
139		return $beforeEvent->getReturnValue();
140		}
141
142		$updatedUserGroup = $beforeEvent->hasReturnValue()
143		? $beforeEvent->getReturnValue()
144		: parent::updateUserGroup($userGroup, $userGroupUpdateStruct);
145
146		$this->eventDispatcher->dispatch(
147		UserEvents::UPDATE_USER_GROUP,
148		new UpdateUserGroupEvent($updatedUserGroup, ...$eventData)
149		);
150
151		return $updatedUserGroup;
152		}
153
154		public function createUser(
155		UserCreateStruct $userCreateStruct,
		@@ 154-178 (lines=25) @@
151		return $updatedUserGroup;
152		}
153
154		public function createUser(
155		UserCreateStruct $userCreateStruct,
156		array $parentGroups
157		) {
158		$eventData = [
159		$userCreateStruct,
160		$parentGroups,
161		];
162
163		$beforeEvent = new BeforeCreateUserEvent(...$eventData);
164		if ($this->eventDispatcher->dispatch(UserEvents::BEFORE_CREATE_USER, $beforeEvent)->isPropagationStopped()) {
165		return $beforeEvent->getReturnValue();
166		}
167
168		$user = $beforeEvent->hasReturnValue()
169		? $beforeEvent->getReturnValue()
170		: parent::createUser($userCreateStruct, $parentGroups);
171
172		$this->eventDispatcher->dispatch(
173		UserEvents::CREATE_USER,
174		new CreateUserEvent($user, ...$eventData)
175		);
176
177		return $user;
178		}
179
180		public function deleteUser(User $user)
181		{
		@@ 180-199 (lines=20) @@
177		return $user;
178		}
179
180		public function deleteUser(User $user)
181		{
182		$eventData = [$user];
183
184		$beforeEvent = new BeforeDeleteUserEvent(...$eventData);
185		if ($this->eventDispatcher->dispatch(UserEvents::BEFORE_DELETE_USER, $beforeEvent)->isPropagationStopped()) {
186		return $beforeEvent->getReturnValue();
187		}
188
189		$locations = $beforeEvent->hasReturnValue()
190		? $beforeEvent->getReturnValue()
191		: parent::deleteUser($user);
192
193		$this->eventDispatcher->dispatch(
194		UserEvents::DELETE_USER,
195		new DeleteUserEvent($locations, ...$eventData)
196		);
197
198		return $locations;
199		}
200
201		public function updateUser(
202		User $user,
		@@ 201-225 (lines=25) @@
198		return $locations;
199		}
200
201		public function updateUser(
202		User $user,
203		UserUpdateStruct $userUpdateStruct
204		) {
205		$eventData = [
206		$user,
207		$userUpdateStruct,
208		];
209
210		$beforeEvent = new BeforeUpdateUserEvent(...$eventData);
211		if ($this->eventDispatcher->dispatch(UserEvents::BEFORE_UPDATE_USER, $beforeEvent)->isPropagationStopped()) {
212		return $beforeEvent->getReturnValue();
213		}
214
215		$updatedUser = $beforeEvent->hasReturnValue()
216		? $beforeEvent->getReturnValue()
217		: parent::updateUser($user, $userUpdateStruct);
218
219		$this->eventDispatcher->dispatch(
220		UserEvents::UPDATE_USER,
221		new UpdateUserEvent($updatedUser, ...$eventData)
222		);
223
224		return $updatedUser;
225		}
226
227		public function updateUserToken(
228		User $user,
		@@ 227-251 (lines=25) @@
224		return $updatedUser;
225		}
226
227		public function updateUserToken(
228		User $user,
229		UserTokenUpdateStruct $userTokenUpdateStruct
230		) {
231		$eventData = [
232		$user,
233		$userTokenUpdateStruct,
234		];
235
236		$beforeEvent = new BeforeUpdateUserTokenEvent(...$eventData);
237		if ($this->eventDispatcher->dispatch(UserEvents::BEFORE_UPDATE_USER_TOKEN, $beforeEvent)->isPropagationStopped()) {
238		return $beforeEvent->getReturnValue();
239		}
240
241		$updatedUser = $beforeEvent->hasReturnValue()
242		? $beforeEvent->getReturnValue()
243		: parent::updateUserToken($user, $userTokenUpdateStruct);
244
245		$this->eventDispatcher->dispatch(
246		UserEvents::UPDATE_USER_TOKEN,
247		new UpdateUserTokenEvent($updatedUser, ...$eventData)
248		);
249
250		return $updatedUser;
251		}
252
253		public function assignUserToUserGroup(
254		User $user,

ezsystems / ezpublish-kernel

Code Duplication Length = 20-25 lines in 35 locations

eZ/Publish/Core/Event/ContentService.php 2 locations

eZ/Publish/Core/Event/ContentTypeService.php 4 locations

eZ/Publish/Core/Event/LanguageService.php 4 locations

eZ/Publish/Core/Event/LocationService.php 2 locations

eZ/Publish/Core/Event/NotificationService.php 1 location

eZ/Publish/Core/Event/ObjectStateService.php 1 location

eZ/Publish/Core/Event/RoleService.php 8 locations

eZ/Publish/Core/Event/SectionService.php 2 locations

eZ/Publish/Core/Event/TrashService.php 2 locations

eZ/Publish/Core/Event/URLService.php 1 location

eZ/Publish/Core/Event/URLWildcardService.php 1 location

eZ/Publish/Core/Event/UserService.php 7 locations