/**
* @param mixed $query
* @param string $lang
* @param string $type
*
* @return mixed|void
*/
public function defineSearch($query, $lang, $type)
{
$query = \Elastica\Util::escapeTerm($query);
$elasticaQueryLang = new \Elastica\Query\Term();
$elasticaQueryLang->setTerm('lang', $lang);
$elasticaQueryString = new \Elastica\Query\Match();
$elasticaQueryString->setFieldQuery('content', $query)->setFieldMinimumShouldMatch('content', '80%');
$elasticaQueryTitle = new \Elastica\Query\QueryString();
$elasticaQueryTitle->setDefaultField('title')->setBoost(2.0)->setQuery($query);
$elasticaQueryBool = new \Elastica\Query\BoolQuery();
$elasticaQueryBool->addMust($elasticaQueryLang)->addShould($elasticaQueryTitle)->addShould($elasticaQueryString)->setMinimumNumberShouldMatch(1);
$this->applySecurityContext($elasticaQueryBool);
if (!is_null($type)) {
$elasticaQueryType = new \Elastica\Query\Term();
$elasticaQueryType->setTerm('type', $type);
$elasticaQueryBool->addMust($elasticaQueryType);
}
$rootNode = $this->domainConfiguration->getRootNode();
if (!is_null($rootNode)) {
$elasticaQueryRoot = new \Elastica\Query\Term();
$elasticaQueryRoot->setTerm('root_id', $rootNode->getId());
$elasticaQueryBool->addMust($elasticaQueryRoot);
}
$this->query->setQuery($elasticaQueryBool);
$this->query->setHighlight(array('pre_tags' => array('<strong>'), 'post_tags' => array('</strong>'), 'fields' => array('content' => array('fragment_size' => 150, 'number_of_fragments' => 3))));
}
/**
* @param RelationDefinition $query
* @param string $lang
* @param string $type
*
* @return void
*/
public function defineSearch($query, $lang, $type)
{
$category = $query->getCategory();
$tags = $query->getTags();
$exclude = $query->getExclude();
$rootNode = $this->domainConfiguration->getRootNode();
$bool = (new Query\BoolQuery())->setMinimumNumberShouldMatch(1);
$bool->addMust((new Term())->setTerm('lang', $this->language));
$bool->addMust((new Term())->setTerm('type', $type));
$bool->addMust((new Term())->setTerm('view_roles', 'IS_AUTHENTICATED_ANONYMOUSLY'));
if ($rootNode instanceof Node) {
$root = new Term();
$root->setTerm('root_id', $rootNode->getId());
$bool->addMust($root);
}
// check if slug is non-empty: avoid filtering for home page
if ($category && $category->getSlug()) {
$bool->addShould((new Term())->setTerm('ancestors', $category->getNodeId()));
}
if ($tags) {
$tagLogic = $this->tagsLogic instanceof TagLogic ?: new TagLogic(TagLogic::LOGIC_FEW);
$minimum = $tagLogic->getMinMatch($tags);
$bool->addShould((new Terms())->setMinimumMatch($minimum)->setTerms('tags', $tags));
}
if (0 !== sizeof($exclude)) {
$bool->addMustNot((new Terms())->setTerms('node_id', $exclude));
}
$this->query = new Query();
$queryDefinition = new QueryDefinition($this->query, $bool);
$this->feed->modifyQuery($queryDefinition);
$queryDefinition->getQuery()->setQuery($queryDefinition->getFilterQuery());
}
public function getPageChildren($page = null, $ofType = null, array $options = [])
{
if (null === $page) {
$page = $this->domainConfiguration->getRootNode();
}
return $this->siteTree->getChildren($page, $options + ['depth' => 0, 'refName' => $this->getRefNames($ofType)]);
}
/**
* @param ContainerInterface $container
* @param SearchProviderInterface $searchProvider
* @param string $name
* @param string $type
*/
public function __construct($container, $searchProvider, $name, $type)
{
$this->container = $container;
$this->indexName = $name;
$this->indexType = $type;
$this->searchProvider = $searchProvider;
$this->domainConfiguration = $this->container->get('kunstmaan_admin.domain_configuration');
$this->locales = $this->domainConfiguration->getBackendLocales();
$this->analyzerLanguages = $this->container->getParameter('analyzer_languages');
$this->em = $this->container->get('doctrine')->getManager();
}
/**
* Build filters for admin list
*/
public function buildFilters()
{
if ($this->domainConfiguration->isMultiDomainHost()) {
$hosts = $this->domainConfiguration->getHosts();
$domains = array_combine($hosts, $hosts);
$domains = array_merge(array('' => 'redirect.all'), $domains);
$this->addFilter('domain', new ORM\EnumerationFilterType('domain'), 'Domain', $domains);
}
$this->addFilter('origin', new ORM\StringFilterType('origin'), 'Origin');
$this->addFilter('target', new ORM\StringFilterType('target'), 'Target');
$this->addFilter('permanent', new ORM\BooleanFilterType('permanent'), 'Permanent');
}
/**
* Builds the form.
*
* This method is called for each type in the hierarchy starting form the
* top most type. Type extensions can further modify the form.
*
* @see FormTypeExtensionInterface::buildForm()
*
* @param FormBuilderInterface $builder The form builder
* @param array $options The options
*/
public function buildForm(FormBuilderInterface $builder, array $options)
{
if ($this->domainConfiguration->isMultiDomainHost()) {
$hosts = $this->domainConfiguration->getHosts();
$domains = array_combine($hosts, $hosts);
$domains = array_merge(array('' => 'redirect.all'), $domains);
$builder->add('domain', 'choice', array('choices' => $domains, 'required' => true, 'expanded' => false, 'multiple' => false));
}
$builder->add('origin', 'text', array('required' => true, 'attr' => array('info_text' => 'redirect.origin_info')));
$builder->add('target', 'text', array('required' => true, 'attr' => array('info_text' => 'redirect.target_info')));
$builder->add('permanent', 'checkbox', array('required' => false));
}
/**
* @param QueryBuilder $queryBuilder The query builder
*/
public function adaptQueryBuilder(QueryBuilder $queryBuilder)
{
parent::adaptQueryBuilder($queryBuilder);
$queryBuilder->select('b,n')->innerJoin('b.node', 'n', 'WITH', 'b.node = n.id')->andWhere('b.lang = :lang')->andWhere('n.deleted = 0')->addOrderBy('b.updated', 'DESC')->setParameter('lang', $this->locale);
if (!$this->domainConfiguration) {
return;
}
$rootNode = $this->domainConfiguration->getRootNode();
if (!is_null($rootNode)) {
$queryBuilder->andWhere('n.lft >= :left')->andWhere('n.rgt <= :right')->setParameter('left', $rootNode->getLeft())->setParameter('right', $rootNode->getRight());
}
}
/**
* @param FilterResponseEvent $event
*/
public function onKernelResponse(FilterResponseEvent $event)
{
if (HttpKernelInterface::MASTER_REQUEST !== $event->getRequestType()) {
return;
}
$response = $event->getResponse();
if ($response instanceof RedirectResponse) {
return;
}
$request = $event->getRequest();
if ($request->isXmlHttpRequest()) {
return;
}
if (!$this->isAdminRoute($request->getRequestUri())) {
return;
}
if ($request->getHost() !== $this->domainConfiguration->getHost()) {
// Add flash message for admin pages
$this->session->getFlashBag()->add('warning', 'multi_domain.host_override_active');
}
}
private function initRoutes()
{
$redirects = $this->redirectRepository->findAll();
$domain = $this->domainConfiguration->getHost();
/** @var Redirect $redirect */
foreach ($redirects as $redirect) {
// Only add the route when the domain matches or the domain is empty
if ($redirect->getDomain() == $domain || !$redirect->getDomain()) {
$this->routeCollection->add('_redirect_route_' . $redirect->getId(), new Route($redirect->getOrigin(), array('_controller' => 'FrameworkBundle:Redirect:urlRedirect', 'path' => $redirect->getTarget(), 'permanent' => $redirect->isPermanent())));
}
}
}
public function configureOptions(OptionsResolver $resolver)
{
parent::configureOptions($resolver);
$resolver->setDefaults(['advanced_select' => true, 'root_node' => function (Options $options) {
return $this->domainConfiguration->getRootNode();
}, 'lang' => function (Options $options) {
return $this->currentLocale->getCurrentLocale();
}, 'class' => function (Options $options) {
return $this->contentTypeService->getContentTypeClass($options['page_name']);
}, 'query_builder' => function (Options $options) {
/** @var QueryBuilder $qb */
$qb = $options['em']->getRepository($options['class'])->createQueryBuilder('e');
$node = $options['root_node'];
if ($node instanceof Node) {
$qb->setParameters(['left' => $node->getLeft(), 'right' => $node->getRight()]);
}
$qb->setParameter('lang', $options['lang']);
return $qb;
}, 'empty_value' => ' ', 'required' => false]);
$resolver->setAllowedTypes('root_node', ['null', Node::class]);
$resolver->setRequired('page_name');
}
/**
* Returns the current root node menu item
*/
public function getRootNodeMenuItem()
{
if (is_null($this->rootNodeMenuItem)) {
$rootNode = $this->domainConfiguration->getRootNode();
if (!is_null($rootNode)) {
$nodeTranslation = $rootNode->getNodeTranslation($this->locale, $this->includeOffline);
$this->rootNodeMenuItem = new NodeMenuItem($rootNode, $nodeTranslation, false, $this);
} else {
$this->rootNodeMenuItem = $this->breadCrumb[0];
}
}
return $this->rootNodeMenuItem;
}
/**
* Get the list of nodes that is used in the admin menu.
*
* @param string $lang
* @param string $permission
* @param AclNativeHelper $aclNativeHelper
* @param bool $includeHiddenFromNav
*
* @return array
*/
private function getTreeNodes($lang, $permission, AclNativeHelper $aclNativeHelper, $includeHiddenFromNav)
{
if (is_null($this->treeNodes)) {
$repo = $this->em->getRepository('KunstmaanNodeBundle:Node');
$this->treeNodes = array();
$rootNode = $this->domainConfiguration->getRootNode();
// Get all nodes that should be shown in the menu
$allNodes = $repo->getAllMenuNodes($lang, $permission, $aclNativeHelper, $includeHiddenFromNav, $rootNode);
/** @var Node $nodeInfo */
foreach ($allNodes as $nodeInfo) {
$refEntityName = $nodeInfo['ref_entity_name'];
if ($this->pagesConfiguration->isHiddenFromTree($refEntityName)) {
continue;
}
$parent_id = is_null($nodeInfo['parent']) ? 0 : $nodeInfo['parent'];
unset($nodeInfo['parent']);
$this->treeNodes[$parent_id][] = $nodeInfo;
}
unset($allNodes);
}
return $this->treeNodes;
}
/**
* @param NodeTranslation $translation The node translation
* @param EntityManager $em The entity manager
* @param array $flashes Flashes
*
* A function that checks the URL and sees if it's unique.
* It's allowed to be the same when the node is a StructureNode.
* When a node is deleted it needs to be ignored in the check.
* Offline nodes need to be included as well.
*
* It sluggifies the slug, updates the URL
* and checks all existing NodeTranslations ([1]), excluding itself. If a
* URL existsthat has the same url. If an existing one is found the slug is
* modified, the URL is updated and the check is repeated until no prior
* urls exist.
*
* NOTE: We need a way to tell if the slug has been modified or not.
* NOTE: Would be cool if we could increment a number after the slug. Like
* check if it matches -v# and increment the number.
*
* [1] For all languages for now. The issue is that we need a way to know
* if a node's URL is prepended with the language or not. For now both
* scenarios are possible so we check for all languages.
*
* @param NodeTranslation &$translation Reference to the NodeTranslation.
* This is modified in place.
* @param EntityManager $em The entity manager
* @param array $flashes The flash messages array
*
* @return bool
*
* @return boolean
*/
private function ensureUniqueUrl(NodeTranslation &$translation, EntityManager $em, $flashes = array())
{
// Can't use GetRef here yet since the NodeVersions aren't loaded yet for some reason.
$nodeVersion = $translation->getPublicNodeVersion();
$page = $em->getRepository($nodeVersion->getRefEntityName())->find($nodeVersion->getRefId());
$isStructureNode = $page->isStructureNode();
// If it's a StructureNode the slug and url should be empty.
if ($isStructureNode) {
$translation->setSlug('');
$translation->setUrl($translation->getFullSlug());
return true;
}
/* @var NodeTranslationRepository $nodeTranslationRepository */
$nodeTranslationRepository = $em->getRepository('KunstmaanNodeBundle:NodeTranslation');
if ($translation->getUrl() == $translation->getFullSlug()) {
$this->logger->addDebug('Evaluating URL for NT ' . $translation->getId() . ' getUrl: \'' . $translation->getUrl() . '\' getFullSlug: \'' . $translation->getFullSlug() . '\'');
return false;
}
// Adjust the URL.
$translation->setUrl($translation->getFullSlug());
// Find all translations with this new URL, whose nodes are not deleted.
$translations = $nodeTranslationRepository->getNodeTranslationForUrl($translation->getUrl(), $translation->getLang(), false, $translation, $this->domainConfiguration->getRootNode());
$this->logger->addDebug('Found ' . count($translations) . ' node(s) that match url \'' . $translation->getUrl() . '\'');
if (count($translations) > 0) {
$oldUrl = $translation->getFullSlug();
$translation->setSlug($this->slugifier->slugify($this->incrementString($translation->getSlug())));
$newUrl = $translation->getFullSlug();
$message = 'The URL of the page has been changed from ' . $oldUrl . ' to ' . $newUrl . ' since another page already uses this URL.';
$this->logger->addInfo($message);
$flashes[] = $message;
$this->ensureUniqueUrl($translation, $em, $flashes);
} elseif (count($flashes) > 0 && $this->isInRequestScope()) {
// No translations found so we're certain we can show this message.
$flash = current(array_slice($flashes, -1));
$this->session->getFlashBag()->add(FlashTypes::WARNING, $flash);
}
return true;
}
public function __construct(DomainConfigurationInterface $domainConfiguration)
{
$locales = $domainConfiguration->getFrontendLocales();
$this->locales = array_combine($locales, $locales);
}
public function getCurrentLocale()
{
$request = $this->requestStack->getCurrentRequest();
return $request ? $request->getLocale() : $this->domainConfiguration->getDefaultLocale();
}
/**
* @return string
*/
protected function getHost()
{
return $this->domainConfiguration->getHost();
}
/**
* @return array
*/
public function getCurrentHost()
{
return $this->domainConfiguration->getHost();
}
/**
* @return array
*/
private function getLocales()
{
return $this->domainConfiguration->getBackendLocales();
}