File: /datos/www/fabricas.colombiatrade.com.co/web_https/core/lib/Drupal/Core/Path/AliasStorage.php
<?php
namespace Drupal\Core\Path;
use Drupal\Core\Database\Connection;
use Drupal\Core\Database\Query\Condition;
use Drupal\Core\Database\Query\SelectInterface;
use Drupal\Core\Entity\EntityTypeManagerInterface;
use Drupal\Core\Extension\ModuleHandlerInterface;
use Drupal\Core\Language\LanguageInterface;
@trigger_error('\Drupal\Core\Path\AliasStorage is deprecated in drupal:8.8.0 and is removed from drupal:9.0.0. Use the "path_alias.repository" service instead, or the entity storage handler for the "path_alias" entity type for CRUD methods. See https://www.drupal.org/node/3013865.', E_USER_DEPRECATED);
/**
* Provides a class for CRUD operations on path aliases.
*
* All queries perform case-insensitive matching on the 'source' and 'alias'
* fields, so the aliases '/test-alias' and '/test-Alias' are considered to be
* the same, and will both refer to the same internal system path.
*
* @deprecated \Drupal\Core\Path\AliasStorage is deprecated in drupal:8.8.0 and
* is removed from drupal:9.0.0. Use the "path_alias.repository" service
* instead, or the entity storage handler for the "path_alias" entity type
* for CRUD methods.
*
* @see https://www.drupal.org/node/3013865
*/
class AliasStorage implements AliasStorageInterface {
/**
* The table for the url_alias storage.
*/
const TABLE = 'path_alias';
/**
* The database connection.
*
* @var \Drupal\Core\Database\Connection
*/
protected $connection;
/**
* The module handler.
*
* @var \Drupal\Core\Extension\ModuleHandlerInterface
*/
protected $moduleHandler;
/**
* The entity type manager.
*
* @var \Drupal\Core\Entity\EntityTypeManagerInterface
*/
protected $entityTypeManager;
/**
* Constructs a Path CRUD object.
*
* @param \Drupal\Core\Database\Connection $connection
* A database connection for reading and writing path aliases.
* @param \Drupal\Core\Extension\ModuleHandlerInterface $module_handler
* The module handler.
* @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
* The entity type manager.
*/
public function __construct(Connection $connection, ModuleHandlerInterface $module_handler, EntityTypeManagerInterface $entity_type_manager = NULL) {
$this->connection = $connection;
$this->moduleHandler = $module_handler;
$this->entityTypeManager = $entity_type_manager ?: \Drupal::entityTypeManager();
}
/**
* {@inheritdoc}
*/
public function save($source, $alias, $langcode = LanguageInterface::LANGCODE_NOT_SPECIFIED, $pid = NULL) {
if ($source[0] !== '/') {
throw new \InvalidArgumentException(sprintf('Source path %s has to start with a slash.', $source));
}
if ($alias[0] !== '/') {
throw new \InvalidArgumentException(sprintf('Alias path %s has to start with a slash.', $alias));
}
if ($pid) {
/** @var \Drupal\path_alias\PathAliasInterface $path_alias */
$path_alias = $this->getPathAliasEntityStorage()->load($pid);
$original_values = [
'source' => $path_alias->getPath(),
'alias' => $path_alias->getAlias(),
'langcode' => $path_alias->get('langcode')->value,
];
$path_alias->setPath($source);
$path_alias->setAlias($alias);
$path_alias->set('langcode', $langcode);
}
else {
$path_alias = $this->getPathAliasEntityStorage()->create([
'path' => $source,
'alias' => $alias,
'langcode' => $langcode,
]);
}
$path_alias->save();
$path_alias_values = [
'pid' => $path_alias->id(),
'source' => $path_alias->getPath(),
'alias' => $path_alias->getAlias(),
'langcode' => $path_alias->get('langcode')->value,
];
if (isset($original_values)) {
$path_alias_values['original'] = $original_values;
}
return $path_alias_values;
}
/**
* {@inheritdoc}
*/
public function load($conditions) {
$query = $this->getPathAliasEntityStorage()->getQuery();
// Ignore access restrictions for this API.
$query->accessCheck(FALSE);
foreach ($conditions as $field => $value) {
if ($field === 'source') {
$field = 'path';
}
elseif ($field === 'pid') {
$field = 'id';
}
$query->condition($field, $value, '=');
}
$result = $query
->sort('id', 'DESC')
->range(0, 1)
->execute();
$entities = $this->getPathAliasEntityStorage()->loadMultiple($result);
/** @var \Drupal\path_alias\PathAliasInterface $path_alias */
$path_alias = reset($entities);
if ($path_alias) {
return [
'pid' => $path_alias->id(),
'source' => $path_alias->getPath(),
'alias' => $path_alias->getAlias(),
'langcode' => $path_alias->get('langcode')->value,
];
}
return FALSE;
}
/**
* {@inheritdoc}
*/
public function delete($conditions) {
$storage = $this->getPathAliasEntityStorage();
$query = $storage->getQuery();
// API functions should be able to access all entities regardless of access
// restrictions. Those need to happen on a higher level.
$query->accessCheck(FALSE);
foreach ($conditions as $field => $value) {
if ($field === 'source') {
$field = 'path';
}
elseif ($field === 'pid') {
$field = 'id';
}
$query->condition($field, $value, '=');
}
$result = $query->execute();
$storage->delete($storage->loadMultiple($result));
}
/**
* Returns a SELECT query for the path_alias base table.
*
* @return \Drupal\Core\Database\Query\SelectInterface
* A Select query object.
*/
protected function getBaseQuery() {
$query = $this->connection->select(static::TABLE, 'base_table');
$query->condition('base_table.status', 1);
return $query;
}
/**
* {@inheritdoc}
*/
public function preloadPathAlias($preloaded, $langcode) {
$select = $this->getBaseQuery()
->fields('base_table', ['path', 'alias']);
if (!empty($preloaded)) {
$conditions = new Condition('OR');
foreach ($preloaded as $preloaded_item) {
$conditions->condition('base_table.path', $this->connection->escapeLike($preloaded_item), 'LIKE');
}
$select->condition($conditions);
}
$this->addLanguageFallback($select, $langcode);
// We order by ID ASC so that fetchAllKeyed() returns the most recently
// created alias for each source. Subsequent queries using fetchField() must
// use ID DESC to have the same effect.
$select->orderBy('base_table.id', 'ASC');
return $select->execute()->fetchAllKeyed();
}
/**
* {@inheritdoc}
*/
public function lookupPathAlias($path, $langcode) {
// See the queries above. Use LIKE for case-insensitive matching.
$select = $this->getBaseQuery()
->fields('base_table', ['alias'])
->condition('base_table.path', $this->connection->escapeLike($path), 'LIKE');
$this->addLanguageFallback($select, $langcode);
$select->orderBy('base_table.id', 'DESC');
return $select->execute()->fetchField();
}
/**
* {@inheritdoc}
*/
public function lookupPathSource($alias, $langcode) {
// See the queries above. Use LIKE for case-insensitive matching.
$select = $this->getBaseQuery()
->fields('base_table', ['path'])
->condition('base_table.alias', $this->connection->escapeLike($alias), 'LIKE');
$this->addLanguageFallback($select, $langcode);
$select->orderBy('base_table.id', 'DESC');
return $select->execute()->fetchField();
}
/**
* Adds path alias language fallback conditions to a select query object.
*
* @param \Drupal\Core\Database\Query\SelectInterface $query
* A Select query object.
* @param string $langcode
* Language code to search the path with. If there's no path defined for
* that language it will search paths without language.
*/
protected function addLanguageFallback(SelectInterface $query, $langcode) {
// Always get the language-specific alias before the language-neutral one.
// For example 'de' is less than 'und' so the order needs to be ASC, while
// 'xx-lolspeak' is more than 'und' so the order needs to be DESC.
$langcode_list = [$langcode, LanguageInterface::LANGCODE_NOT_SPECIFIED];
if ($langcode === LanguageInterface::LANGCODE_NOT_SPECIFIED) {
array_pop($langcode_list);
}
elseif ($langcode > LanguageInterface::LANGCODE_NOT_SPECIFIED) {
$query->orderBy('base_table.langcode', 'DESC');
}
else {
$query->orderBy('base_table.langcode', 'ASC');
}
$query->condition('base_table.langcode', $langcode_list, 'IN');
}
/**
* {@inheritdoc}
*/
public function aliasExists($alias, $langcode, $source = NULL) {
// Use LIKE and NOT LIKE for case-insensitive matching.
$query = $this->connection->select(static::TABLE)
->condition('alias', $this->connection->escapeLike($alias), 'LIKE')
->condition('langcode', $langcode);
if (!empty($source)) {
$query->condition('path', $this->connection->escapeLike($source), 'NOT LIKE');
}
$query->addExpression('1');
$query->range(0, 1);
return (bool) $query->execute()->fetchField();
}
/**
* {@inheritdoc}
*/
public function languageAliasExists() {
return (bool) $this->connection->queryRange('SELECT 1 FROM {' . static::TABLE . '} WHERE langcode <> :langcode', 0, 1, [':langcode' => LanguageInterface::LANGCODE_NOT_SPECIFIED])->fetchField();
}
/**
* {@inheritdoc}
*/
public function getAliasesForAdminListing($header, $keys = NULL) {
$query = $this->connection->select(static::TABLE)
->extend('Drupal\Core\Database\Query\PagerSelectExtender')
->extend('Drupal\Core\Database\Query\TableSortExtender');
if ($keys) {
// Replace wildcards with PDO wildcards.
$query->condition('alias', '%' . preg_replace('!\*+!', '%', $keys) . '%', 'LIKE');
}
$query->addField(static::TABLE, 'id', 'pid');
$query->addField(static::TABLE, 'path', 'source');
return $query
->fields(static::TABLE, ['alias', 'langcode'])
->orderByHeader($header)
->limit(50)
->execute()
->fetchAll();
}
/**
* {@inheritdoc}
*/
public function pathHasMatchingAlias($initial_substring) {
if (!$this->moduleHandler->moduleExists('path_alias')) {
return FALSE;
}
$query = $this->getBaseQuery();
$query->addExpression(1);
return (bool) $query
->condition('base_table.path', $this->connection->escapeLike($initial_substring) . '%', 'LIKE')
->range(0, 1)
->execute()
->fetchField();
}
/**
* Returns the path alias entity storage handler.
*
* We can not store it in the constructor because that leads to a circular
* dependency in the service container.
*
* @return \Drupal\Core\Entity\EntityStorageInterface
* The path alias entity storage.
*/
protected function getPathAliasEntityStorage() {
return $this->entityTypeManager->getStorage('path_alias');
}
}