/** * @param Location $location * @return mixed */ public function getContentDecorator(Location $location) { $mappingEntities = $this->configResolver->getParameter('class_mapping', 'ezcontentdecorator'); $contentTypeIdentifier = $this->repository->getContentTypeService()->loadContentType($location->contentInfo->contentTypeId)->identifier; $className = array_key_exists($contentTypeIdentifier, $mappingEntities) ? $mappingEntities[$contentTypeIdentifier] : $this->defaultClassName; return new $className($this->container, $location, $contentTypeIdentifier); }
public function onKernelRequest(GetResponseEvent $event) { $request = $event->getRequest(); if (!$request->attributes->get('is_rest_request')) { return; } if (($contentTypeHeaderValue = $request->headers->get('content-type')) === null) { return; } list($mediaType) = explode('+', $contentTypeHeaderValue); if (strtolower($mediaType) == !'application/vnd.ez.api.contentcreate') { return; } $message = $this->buildMessage($request); if (!$message->body) { return; } $result = $this->restInputDispatcher->parse($message); if (!$result instanceof RestContentCreateStruct) { return; } // Not a user if (($userCreateData = $this->mapContentCreateToUserCreate($result)) === false) { return; } list($userCreateStruct, $userGroup) = $userCreateData; $createdUser = $this->repository->getUserService()->createUser($userCreateStruct, [$userGroup]); $createdContentInfo = $createdUser->contentInfo; $createdLocation = $this->repository->getLocationService()->loadLocation($createdContentInfo->mainLocationId); $contentType = $this->repository->getContentTypeService()->loadContentType($createdContentInfo->contentTypeId); $result = new CreatedContent(array('content' => new RestContent($createdContentInfo, $createdLocation, $this->repository->getContentService()->loadContent($createdContentInfo->id), $contentType, $this->repository->getContentService()->loadRelations($createdUser->getVersionInfo())))); $event->setResponse($this->viewDispatcher->dispatch($event->getRequest(), $result)); }
public function castContentInfo(ContentInfo $info, array $a, Stub $stub, $isNested, $filter = 0) { $a = [Caster::PREFIX_PROTECTED . 'id' => $info->id, Caster::PREFIX_PROTECTED . 'name' => $info->name] + $a; if (!$filter & Caster::EXCLUDE_VERBOSE) { $contentType = $this->repository->getContentTypeService()->loadContentType($info->contentTypeId); $a[Caster::PREFIX_VIRTUAL . 'contentTypeName'] = $contentType->getName($info->mainLanguageCode); } return $a; }
/** * Gets content type identifier of field corresponding with the given node * * @param TreeNodeInterface $node * @return string */ public function getContentTypeIdentifier(TreeNodeInterface $node) { $parent = $node->getParent(); $fieldName = $parent->getName(); $grandPa = $parent->getParent()->getParent(); $contentTypeNode = $grandPa->getChildByName('content_type'); $contentType = $this->repository->getContentTypeService()->loadContentTypeByIdentifier($contentTypeNode->getValue()); $fieldDefinition = $contentType->getFieldDefinition($fieldName); return $fieldDefinition->fieldTypeIdentifier; }
/** * @param \eZ\Publish\API\Repository\Repository $repository * @param ConfigResolverInterface|\Psr\Log\LoggerInterface $resolver */ public function __construct(Repository $repository, ConfigResolverInterface $resolver) { $this->repository = $repository; $this->searchService = $this->repository->getSearchService(); $this->locationService = $this->repository->getLocationService(); $this->contentService = $this->repository->getContentService(); $this->languageService = $this->repository->getContentLanguageService(); $this->userService = $this->repository->getUserService(); $this->contentTypeService = $this->repository->getContentTypeService(); $this->configResolver = $resolver; }
/** * @param $login * @param $email * @param $firstName * @param $lastName * @return User */ public function createNewUser($login, $email, $firstName, $lastName) { $userService = $this->repository->getUserService(); $userCreateStruct = $userService->newUserCreateStruct($login, $email, md5($email . $login . time() . rand(1, 10000)), 'eng-GB', $this->repository->getContentTypeService()->loadContentTypeByIdentifier('user')); $userCreateStruct->setField('first_name', $firstName); $userCreateStruct->setField('last_name', $lastName); $user = $this->repository->sudo(function () use($userService, $userCreateStruct) { $userGroup = $userService->loadUserGroup('11'); // guest accounts return $userService->createUser($userCreateStruct, array($userGroup)); }); return $user; }
/** * Instantiate a user group create class * * @param string $mainLanguageCode The main language for the underlying content object * @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 * * @return \eZ\Publish\API\Repository\Values\User\UserGroupCreateStruct */ public function newUserGroupCreateStruct($mainLanguageCode, $contentType = null) { if ($contentType === null) { $contentType = $this->repository->getContentTypeService()->loadContentType($this->settings['userGroupClassID']); } return new UserGroupCreateStruct(array('contentType' => $contentType, 'mainLanguageCode' => $mainLanguageCode, 'fields' => array())); }
/** * Convenience method for resolving name schema * * @param \eZ\Publish\API\Repository\Values\Content\Content $content * @param array $fieldMap * @param array $languageCodes * @param \eZ\Publish\API\Repository\Values\ContentType\ContentType|null $contentType * * @return array */ public function resolveNameSchema(Content $content, array $fieldMap = array(), array $languageCodes = array(), ContentType $contentType = null) { if ($contentType === null) { $contentType = $this->repository->getContentTypeService()->loadContentType($content->contentInfo->contentTypeId); } $languageCodes = $languageCodes ?: $content->versionInfo->languageCodes; return $this->resolve($contentType->nameSchema, $contentType, $this->mergeFieldMap($content, $fieldMap, $languageCodes), $languageCodes); }
/** * Get Content Type Service * * Get service object to perform operations on Content Type objects and it's aggregate members. * ( Group, Field & FieldCategory ) * * @return \eZ\Publish\API\Repository\ContentTypeService */ public function getContentTypeService() { if ($this->contentTypeService !== null) { return $this->contentTypeService; } $this->contentTypeService = new ContentTypeService($this->repository->getContentTypeService(), $this->signalDispatcher); return $this->contentTypeService; }
/** * Get ContentType by Content/ContentInfo. * * @param \eZ\Publish\API\Repository\Values\Content\Content|\eZ\Publish\API\Repository\Values\Content\ContentInfo $content * * @return \eZ\Publish\API\Repository\Values\ContentType\ContentType|null */ private function getContentType(ValueObject $content) { if ($content instanceof Content) { return $this->repository->getContentTypeService()->loadContentType($content->getVersionInfo()->getContentInfo()->contentTypeId); } elseif ($content instanceof ContentInfo) { return $this->repository->getContentTypeService()->loadContentType($content->contentTypeId); } }
/** * Returns a field value for the given value * $version->fields[$fieldDefId][$languageCode] is an equivalent call * if no language is given on a translatable field this method returns * the value of the initial language of the version if present, otherwise null. * On non translatable fields this method ignores the languageCode parameter. * * @param string $fieldDefIdentifier * @param string $languageCode * * @return mixed a primitive type or a field type Value object depending on the field type. */ public function getFieldValue($fieldDefIdentifier, $languageCode = null) { $contentType = $this->repository->getContentTypeService()->loadContentType($this->contentTypeId); $translatable = $contentType->getFieldDefinition($fieldDefIdentifier)->isTranslatable; if (null === $languageCode) { $languageCode = $this->getVersionInfo()->getContentInfo()->mainLanguageCode; } foreach ($this->getFields() as $field) { if ($field->fieldDefIdentifier !== $fieldDefIdentifier) { continue; } if ($translatable && $field->languageCode !== $languageCode) { continue; } return $field->value; } return null; }
public function __construct(Repository $repository, CategoryServiceInterface $categoryService, PostServiceInterface $postService) { $this->repository = $repository; $this->categoryService = $categoryService; $this->postService = $postService; $this->searchService = $repository->getSearchService(); $this->contentService = $repository->getContentService(); $this->locationService = $repository->getLocationService(); $this->contentTypeService = $repository->getContentTypeService(); $this->userService = $repository->getUserService(); }
/** * Builds API Relation object from provided SPI Relation object * * @param \eZ\Publish\SPI\Persistence\Content\Relation $spiRelation * @param \eZ\Publish\API\Repository\Values\Content\ContentInfo $sourceContentInfo * @param \eZ\Publish\API\Repository\Values\Content\ContentInfo $destinationContentInfo * * @return \eZ\Publish\API\Repository\Values\Content\Relation */ public function buildRelationDomainObject(SPIRelation $spiRelation, ContentInfo $sourceContentInfo, ContentInfo $destinationContentInfo) { $sourceFieldDefinitionIdentifier = null; if ($spiRelation->sourceFieldDefinitionId !== null) { /** @var \eZ\Publish\Core\Repository\Values\ContentType\ContentType $contentType */ $contentType = $this->repository->getContentTypeService()->loadContentType($sourceContentInfo->contentTypeId); // Note: getFieldDefinitionById() is not part of API $sourceFieldDefinitionIdentifier = $contentType->getFieldDefinitionById($spiRelation->sourceFieldDefinitionId)->identifier; } return new Relation(array("id" => $spiRelation->id, "sourceFieldDefinitionIdentifier" => $sourceFieldDefinitionIdentifier, "type" => $spiRelation->type, "sourceContentInfo" => $sourceContentInfo, "destinationContentInfo" => $destinationContentInfo)); }
/** * Uses a content type identifier + a hash of fields values * to create and publish a draft below the root location. * * @param string $contentTypeIdentifier * @param array $fields Hash of field def identifier => field value * * @return Content the created draft. */ public function createDraft($contentTypeIdentifier, array $fields) { $contentService = $this->repository->getContentService(); $createStruct = $contentService->newContentCreateStruct($this->repository->getContentTypeService()->loadContentTypeByIdentifier($contentTypeIdentifier), 'eng-GB'); foreach ($fields as $fieldDefIdentifier => $fieldValue) { $createStruct->setField($fieldDefIdentifier, $fieldValue); } $locationCreateStruct = $this->repository->getLocationService()->newLocationCreateStruct(2); $this->currentDraft = $this->repository->sudo(function () use($createStruct, $locationCreateStruct) { return $this->repository->getContentService()->createContent($createStruct, [$locationCreateStruct]); }); return $this->currentDraft; }
/** * Helper to quickly create content. * * @see https://github.com/ezsystems/CookbookBundle/blob/master/Command/CreateContentCommand.php eZ Publish Cookbook * * Usage: * <code> * $this->createContent(2, 'folder', 'eng-GB', [ * 'title' => 'Folder Title', * ]); * </code> * * @param int $parentLocationId * @param string $contentTypeIdentifier * @param string $languageCode * @param array $fields * * @throws NotFoundException If the content type or parent location could not be found * @throws ContentFieldValidationException If an invalid field value has been provided * @throws ContentValidationException If a required field is missing or empty * * @return Content */ protected function createContent($parentLocationId, $contentTypeIdentifier, $languageCode, array $fields) { $contentService = $this->repository->getContentService(); $locationService = $this->repository->getLocationService(); $contentTypeService = $this->repository->getContentTypeService(); $contentType = $contentTypeService->loadContentTypeByIdentifier($contentTypeIdentifier); $contentCreateStruct = $contentService->newContentCreateStruct($contentType, $languageCode); foreach ($fields as $key => $value) { $contentCreateStruct->setField($key, $value); } $locationCreateStruct = $locationService->newLocationCreateStruct($parentLocationId); $draft = $contentService->createContent($contentCreateStruct, [$locationCreateStruct]); $content = $contentService->publishVersion($draft->getVersionInfo()); return $content; }
/** * @param $contentTypeId * @return bool|string */ public function getContentTypeIdentifier($contentTypeId) { if (isset($this->cacheContentTypeIdentifier[$contentTypeId])) { return $this->cacheContentTypeIdentifier[$contentTypeId]; } $cs = $this->repository->getContentTypeService(); try { $ct = $cs->loadContentType($contentTypeId); $contentTypeIdentifier = $ct->identifier; $this->cacheContentTypeIdentifier[$contentTypeId] = $contentTypeIdentifier; return $contentTypeIdentifier; } catch (\eZ\Publish\API\Repository\Exceptions\NotFoundException $error) { return false; } }
/** * Get the ContentType depending on the input arguments * * @param InputInterface $input * * @return ContentType[] */ protected function getContentTypes(InputInterface $input) { $contentTypes = []; $contentTypeService = $this->eZPublishRepository->getContentTypeService(); if ($contentTypeGroupIdentifier = $input->getOption('group_identifier')) { $contentTypeGroup = $contentTypeService->loadContentTypeGroupByIdentifier($contentTypeGroupIdentifier); $contentTypes = $contentTypeService->loadContentTypes($contentTypeGroup); } if ($contentTypeIdentifiers = explode(",", $input->getOption('identifiers'))) { foreach ($contentTypeIdentifiers as $identifier) { if ($identifier != "") { $contentTypes[] = $contentTypeService->loadContentTypeByIdentifier($identifier); } } } if ($contentTypeIdentifier = $input->getOption('identifier')) { $contentTypes[] = $contentTypeService->loadContentTypeByIdentifier($contentTypeIdentifier); } return $contentTypes; }
/** * Compute Metas of the Field thanks to its Content and the Fallback * * @param Field $field * @param ContentInfo $contentInfo * * @return string */ public function computeMetas(Field $field, ContentInfo $contentInfo) { $fallback = false; $languages = $this->configResolver->getParameter('languages'); $contentType = $this->eZRepository->getContentTypeService()->loadContentType($contentInfo->contentTypeId); $content = $this->eZRepository->getContentService()->loadContentByContentInfo($contentInfo, $languages); $contentMetas = $this->innerComputeMetas($content, $field, $contentType, $fallback); if ($fallback) { $rootNode = $this->eZRepository->getLocationService()->loadLocation($this->configResolver->getParameter("content.tree_root.location_id")); $rootContent = $this->eZRepository->getContentService()->loadContentByContentInfo($rootNode->contentInfo, $languages); $rootContentType = $this->eZRepository->getContentTypeService()->loadContentType($rootContent->contentInfo->contentTypeId); // We need to load the good field too $metasIdentifier = $this->configResolver->getParameter('fieldtype_metas_identifier', 'novae_zseo'); $rootMetas = $this->innerComputeMetas($rootContent, $metasIdentifier, $rootContentType, $fallback); foreach ($contentMetas as $key => $metaContent) { if (array_key_exists($key, $rootMetas)) { $metaContent->setContent($metaContent->isEmpty() ? $rootMetas[$key]->getContent() : $metaContent->getContent()); } } } return ''; }
/** * Send message to admin(s) */ public function sendMessage($data, $user, $contentId, $sessionId, $commentId) { if ($user === null) { $name = $data[$this->translator->trans('name')]; $email = $data[$this->translator->trans('email')]; } else { $name = $user->versionInfo->contentInfo->name; $email = $user->email; } $approve_url = $this->getModerationURL($contentId, $commentId, $sessionId, 'approve'); $reject_url = $this->getModerationURL($contentId, $commentId, $sessionId, 'reject'); $content = $this->repository->getContentService()->loadContent($contentId); $contentType = $this->repository->getContentTypeService()->loadContentType($content->getVersionInfo()->getContentInfo()->contentTypeId); if ($contentType->identifier == 'livre_or') { $this->moderate_template = 'DigitInnFrontBundle:Mail:livre_dor_comment_moderation.html.twig'; } $article_nom = $content->getFieldValue('title')->text; $subject = $article_nom . ' - ' . $this->moderate_subject; $article_url = $this->router->generate('ez_urlalias', array('contentId' => $contentId), true); $message = \Swift_Message::newInstance()->setContentType('text/html')->setSubject($subject)->setFrom($this->moderate_from)->setTo($this->moderate_to)->setBody($this->templating->render($this->moderate_template, array("name" => $name, "email" => $email, "comment" => $data[$this->translator->trans('message')], "article_url" => $article_url, "article_nom" => $article_nom, "approve_url" => $approve_url, "reject_url" => $reject_url))); $this->mailer->send($message); }
/** * Returns the field type identifier for $field * * @param \eZ\Publish\API\Repository\Values\Content\Content $content * @param \eZ\Publish\API\Repository\Values\Content\Field $field * * @return string */ protected function getFieldTypeIdentifier(Content $content, Field $field) { $contentType = $this->repository->getContentTypeService()->loadContentType($content->getVersionInfo()->getContentInfo()->contentTypeId); $key = $contentType->identifier . ' ' . $field->fieldDefIdentifier; if (!isset($this->fieldTypeIdentifiers[$key])) { $this->fieldTypeIdentifiers[$key] = $contentType->getFieldDefinition($field->fieldDefIdentifier)->fieldTypeIdentifier; } return $this->fieldTypeIdentifiers[$key]; }
/** * @return mixed */ protected function getPlaceContentType() { return $this->apiRepository->getContentTypeService()->loadContentTypeByIdentifier('place'); }
/** * @param Repository $repository * @param int $parentLocationId * * @return \eZ\Publish\API\Repository\Values\Content\Content */ protected function createNewContentInPlaceTrashedOne(Repository $repository, $parentLocationId) { $contentService = $repository->getContentService(); $locationService = $repository->getLocationService(); $contentTypeService = $repository->getContentTypeService(); $contentType = $contentTypeService->loadContentTypeByIdentifier('forum'); $newContent = $contentService->newContentCreateStruct($contentType, 'eng-US'); $newContent->setField('name', 'Media'); $location = $locationService->newLocationCreateStruct($parentLocationId); $draftContent = $contentService->createContent($newContent, [$location]); return $contentService->publishVersion($draftContent->versionInfo); }