File: /datos/www/fabricas.colombiatrade.com.co/web_https/modules/contrib/xmlsitemap/xmlsitemap.module
<?php
/**
* @file
* @defgroup xmlsitemap XML sitemap
*/
/**
* @file
* Main file for the xmlsitemap module.
*/
use Drupal\Component\Utility\Crypt;
use Drupal\Component\Utility\Environment;
use Drupal\Component\Utility\UrlHelper;
use Drupal\Core\Cache\Cache;
use Drupal\Core\Database\Query\AlterableInterface;
use Drupal\Core\Database\Query\Condition;
use Drupal\Core\Entity\ContentEntityFormInterface;
use Drupal\Core\Entity\ContentEntityInterface;
use Drupal\Core\Entity\ContentEntityTypeInterface;
use Drupal\Core\Entity\EntityInterface;
use Drupal\Core\Entity\EntityTypeInterface;
use Drupal\Core\File\FileSystemInterface;
use Drupal\Core\Form\FormStateInterface;
use Drupal\Core\Language\LanguageInterface;
use Drupal\Core\Link;
use Drupal\Core\Routing\RouteMatchInterface;
use Drupal\Core\Site\Settings;
use Drupal\Core\Url;
use Drupal\xmlsitemap\Controller\XmlSitemapController;
use Drupal\xmlsitemap\Entity\XmlSitemap;
use Drupal\xmlsitemap\XmlSitemapInterface;
use Symfony\Component\HttpFoundation\Request;
/**
* The maximum number of links in one sitemap chunk file.
*/
const XMLSITEMAP_MAX_SITEMAP_LINKS = 50000;
/**
* The maximum filesize of a sitemap chunk file.
*/
const XMLSITEMAP_MAX_SITEMAP_FILESIZE = 52528800;
/**
* Xmlsitemap Frequencies.
*/
const XMLSITEMAP_FREQUENCY_YEARLY = 31449600;
// 60 * 60 * 24 * 7 * 52.
const XMLSITEMAP_FREQUENCY_MONTHLY = 2419200;
// 60 * 60 * 24 * 7 * 4.
const XMLSITEMAP_FREQUENCY_WEEKLY = 604800;
// 60 * 60 * 24 * 7.
const XMLSITEMAP_FREQUENCY_DAILY = 86400;
// 60 * 60 * 24.
const XMLSITEMAP_FREQUENCY_HOURLY = 3600;
// 60 * 60.
const XMLSITEMAP_FREQUENCY_ALWAYS = 60;
/**
* Short lastmod timestamp format.
*/
const XMLSITEMAP_LASTMOD_SHORT = 'Y-m-d';
/**
* Medium lastmod timestamp format.
*/
const XMLSITEMAP_LASTMOD_MEDIUM = 'Y-m-d\TH:i\Z';
/**
* Long lastmod timestamp format.
*/
const XMLSITEMAP_LASTMOD_LONG = 'c';
/**
* The default inclusion status for link types in the sitemaps.
*/
const XMLSITEMAP_STATUS_DEFAULT = 0;
/**
* The default priority for link types in the sitemaps.
*/
const XMLSITEMAP_PRIORITY_DEFAULT = 0.5;
/**
* Implements hook_hook_info().
*/
function xmlsitemap_hook_info() {
$hooks = [
'xmlsitemap_link_info',
'xmlsitemap_link_info_alter',
'xmlsitemap_link_alter',
'xmlsitemap_index_links',
'xmlsitemap_context_info',
'xmlsitemap_context_info_alter',
'xmlsitemap_context_url_options',
'xmlsitemap_context',
'xmlsitemap_element_alter',
'xmlsitemap_root_attributes_alter',
'xmlsitemap_sitemap_insert',
'xmlsitemap_sitemap_update',
'xmlsitemap_sitemap_operations',
'xmlsitemap_sitemap_delete',
'xmlsitemap_sitemap_link_url_options_alter',
'query_xmlsitemap_generate_alter',
'query_xmlsitemap_index_links_alter',
'form_xmlsitemap_sitemap_edit_form_alter',
'xmlsitemap_rebuild_clear',
];
$hooks = array_combine($hooks, $hooks);
foreach ($hooks as $hook => $info) {
$hooks[$hook] = ['group' => 'xmlsitemap'];
}
return $hooks;
}
/**
* Implements hook_help().
*/
function xmlsitemap_help($route_name, RouteMatchInterface $route_match) {
$output = '';
switch ($route_name) {
case 'help.page.xmlsitemap':
case 'xmlsitemap.admin_settings':
case 'xmlsitemap.entities_settings':
case 'entity.xmlsitemap.edit_form':
case 'entity.xmlsitemap.delete_form':
return;
case 'xmlsitemap.admin_search':
break;
case 'xmlsitemap.admin_search_list':
break;
case 'xmlsitemap.admin_rebuild':
$output .= '<p>' . t("This action rebuilds your site's XML sitemap and regenerates the cached files, and may be a lengthy process. If you just installed XML sitemap, this can be helpful to import all your site's content into the sitemap. Otherwise, this should only be used in emergencies.") . '</p>';
}
$currentUser = \Drupal::currentUser();
if (strpos($route_name, 'xmlsitemap') !== FALSE && $currentUser->hasPermission('administer xmlsitemap')) {
// Alert the user to any potential problems detected by hook_requirements.
$output .= _xmlsitemap_get_blurb();
}
return $output;
}
/**
* Implements hook_theme().
*/
function xmlsitemap_theme() {
return [
'xmlsitemap_content_settings_table' => [
'render element' => 'element',
'file' => 'xmlsitemap.module',
],
];
}
/**
* Menu access callback; determines if the user can use the rebuild links page.
*
* @return bool
* Returns TRUE if current user can access rebuild form. FALSE otherwise.
*/
function _xmlsitemap_rebuild_form_access() {
$rebuild_types = xmlsitemap_get_rebuildable_link_types();
return !empty($rebuild_types) && \Drupal::currentUser()->hasPermission('administer xmlsitemap');
}
/**
* Implements hook_cron().
*
* @todo Use new Queue system. Need to add {sitemap}.queued.
* @todo Regenerate one at a time?
*/
function xmlsitemap_cron() {
// If cron sitemap file regeneration is disabled, stop.
if (\Drupal::config('xmlsitemap.settings')->get('disable_cron_regeneration')) {
return;
}
// If there were no new or changed links, skip.
if (!\Drupal::state()->get('xmlsitemap_regenerate_needed')) {
return;
}
// If the minimum sitemap lifetime hasn't been passed, skip.
$lifetime = \Drupal::time()->getRequestTime() - \Drupal::state()->get('xmlsitemap_generated_last');
if ($lifetime < \Drupal::config('xmlsitemap.settings')->get('minimum_lifetime')) {
return;
}
xmlsitemap_xmlsitemap_index_links(\Drupal::config('xmlsitemap.settings')->get('batch_limit'));
// Regenerate the sitemap XML files.
xmlsitemap_run_unprogressive_batch('xmlsitemap_regenerate_batch');
}
/**
* Implements hook_modules_installed().
*/
function xmlsitemap_modules_installed(array $modules) {
Cache::invalidateTags(['xmlsitemap']);
}
/**
* Implements hook_modules_uninstalled().
*/
function xmlsitemap_modules_uninstalled(array $modules) {
Cache::invalidateTags(['xmlsitemap']);
}
/**
* Implements hook_robotstxt().
*/
function xmlsitemap_robotstxt() {
if ($sitemap = XmlSitemap::loadByContext()) {
$uri = xmlsitemap_sitemap_uri($sitemap);
$path = UrlHelper::isExternal($uri['path']) ? $uri['path'] : 'base://' . $uri['path'];
$robotstxt[] = 'Sitemap: ' . Url::fromUri($path, $uri['options'])->toString();
return $robotstxt;
}
}
/**
* Internal default variables config for xmlsitemap_var().
*
* @return array
* Array with config variables of xmlsitemap.settings config object.
*/
function xmlsitemap_config_variables() {
return [
'minimum_lifetime' => 0,
'xsl' => 1,
'prefetch_aliases' => 1,
'chunk_size' => 'auto',
'batch_limit' => 100,
'path' => 'xmlsitemap',
'frontpage_priority' => 1.0,
'frontpage_changefreq' => XMLSITEMAP_FREQUENCY_DAILY,
'lastmod_format' => XMLSITEMAP_LASTMOD_MEDIUM,
'gz' => FALSE,
'disable_cron_regeneration' => FALSE,
];
}
/**
* Internal default variables state for xmlsitemap_var().
*
* @return array
* Array with state variables defined by xmlsitemap module.
*/
function xmlsitemap_state_variables() {
return [
'xmlsitemap_rebuild_needed' => FALSE,
'xmlsitemap_regenerate_needed' => TRUE,
'xmlsitemap_base_url' => '',
'xmlsitemap_generated_last' => 0,
'xmlsitemap_developer_mode' => 0,
'max_chunks' => NULL,
'max_filesize' => NULL,
];
}
/**
* Internal implementation of variable_get().
*/
function xmlsitemap_var($name, $default = NULL) {
$defaults = &drupal_static(__FUNCTION__);
if (!isset($defaults)) {
$defaults = xmlsitemap_config_variables();
$defaults += xmlsitemap_state_variables();
}
// @todo Remove when stable.
if (!isset($defaults[$name])) {
trigger_error("Default variable for $name not found.");
}
if (\Drupal::state()->get($name, NULL) === NULL) {
return \Drupal::config('xmlsitemap.settings')->get($name);
}
return \Drupal::state()->get($name);
}
/**
* @defgroup xmlsitemap_api XML sitemap API.
* @{
* This is the XML sitemap API to be used by modules wishing to work with
* XML sitemap and/or link data.
*/
/**
* Load an XML sitemap array from the database.
*
* @param mixed $smid
* An XML sitemap ID.
*
* @return \Drupal\xmlsitemap\XmlSitemapInterface
* The XML sitemap object.
*/
function xmlsitemap_sitemap_load($smid) {
$sitemap = xmlsitemap_sitemap_load_multiple([$smid]);
return $sitemap ? reset($sitemap) : FALSE;
}
/**
* Load multiple XML sitemaps from the database.
*
* @param array|bool $smids
* An array of XML sitemap IDs, or FALSE to load all XML sitemaps.
* @param array $conditions
* An array of conditions in the form 'field' => $value.
*
* @return \Drupal\xmlsitemap\XmlSitemapInterface[]
* An array of XML sitemap objects.
*/
function xmlsitemap_sitemap_load_multiple($smids = [], array $conditions = []) {
if ($smids !== FALSE) {
$conditions['smid'] = $smids;
}
else {
$conditions['smid'] = NULL;
}
$storage = Drupal::entityTypeManager()->getStorage('xmlsitemap');
/** @var \Drupal\xmlsitemap\XmlSitemapInterface[] $sitemaps */
$sitemaps = $storage->loadMultiple($conditions['smid']);
if (count($sitemaps) <= 0) {
return [];
}
return $sitemaps;
}
/**
* Save changes to an XML sitemap or add a new XML sitemap.
*
* @param Drupal\xmlsitemap\XmlSitemapInterface $sitemap
* The XML sitemap array to be saved. If $sitemap->smid is omitted, a new
* XML sitemap will be added.
*
* @todo Save the sitemap's URL as a column?
*/
function xmlsitemap_sitemap_save(XmlSitemapInterface $sitemap) {
$context = $sitemap->context;
if (!isset($context) || !$context) {
$sitemap->context = [];
}
// Make sure context is sorted before saving the hash.
$sitemap->setOriginalId($sitemap->isNew() ? NULL : $sitemap->getId());
$sitemap->setId(xmlsitemap_sitemap_get_context_hash($context));
// If the context was changed, we need to perform additional actions.
if (!$sitemap->isNew() && $sitemap->getId() != $sitemap->getOriginalId()) {
// Rename the files directory so the sitemap does not break.
$old_sitemap = xmlsitemap_sitemap_load($sitemap->getOriginalId());
$old_dir = xmlsitemap_get_directory($old_sitemap);
$new_dir = xmlsitemap_get_directory($sitemap);
xmlsitemap_directory_move($old_dir, $new_dir);
// Mark the sitemaps as needing regeneration.
\Drupal::state()->set('xmlsitemap_regenerate_needed', TRUE);
}
$sitemap->save();
return $sitemap;
}
/**
* Delete an XML sitemap.
*
* @param string $smid
* An XML sitemap ID.
*/
function xmlsitemap_sitemap_delete($smid) {
xmlsitemap_sitemap_delete_multiple([$smid]);
}
/**
* Delete multiple XML sitemaps.
*
* @param array $smids
* An array of XML sitemap IDs.
*/
function xmlsitemap_sitemap_delete_multiple(array $smids) {
if (!empty($smids)) {
$sitemaps = xmlsitemap_sitemap_load_multiple($smids);
foreach ($sitemaps as $sitemap) {
$sitemap->delete();
\Drupal::moduleHandler()->invokeAll('xmlsitemap_sitemap_delete', [$sitemap]);
}
}
}
/**
* Return the expected file path for a specific sitemap chunk.
*
* @param Drupal\xmlsitemap\XmlSitemapInterface $sitemap
* An XmlSitemapInterface sitemap object.
* @param string $chunk
* An optional specific chunk in the sitemap. Defaults to the index page.
*
* @return string
* File path for a specific sitemap chunk.
*/
function xmlsitemap_sitemap_get_file(XmlSitemapInterface $sitemap, $chunk = 'index') {
return xmlsitemap_get_directory($sitemap) . "/{$chunk}.xml";
}
/**
* Find the maximum file size of all a sitemap's XML files.
*
* @param \Drupal\xmlsitemap\XmlSitemapInterface $sitemap
* The XML sitemap object.
*
* @return int
* Maximum file size in the directory.
*/
function xmlsitemap_sitemap_get_max_filesize(XmlSitemapInterface $sitemap) {
$dir = xmlsitemap_get_directory($sitemap);
$sitemap->setMaxFileSize(0);
/** @var \Drupal\Core\File\FileSystemInterface $file_system */
$file_system = \Drupal::service('file_system');
$files = $file_system->scanDirectory($dir, '/\.xml$/');
foreach ($files as $file) {
$sitemap->setMaxFileSize(max($sitemap->getMaxFileSize(), filesize($file->uri)));
}
return $sitemap->getMaxFileSize();
}
/**
* Returns the hash string for a context.
*
* @param array $context
* Context to be hashed.
*
* @return string
* Hash string for the context.
*/
function xmlsitemap_sitemap_get_context_hash(array &$context) {
ksort($context);
return Crypt::hashBase64(serialize($context));
}
/**
* Returns the uri elements of an XML sitemap.
*
* @param \Drupal\xmlsitemap\XmlSitemapInterface $sitemap
* The sitemap represented by and XmlSitemapInterface object.
*
* @return array
* An array containing the 'path' and 'options' keys used to build the uri of
* the XML sitemap, and matching the signature of url().
*/
function xmlsitemap_sitemap_uri(XmlSitemapInterface $sitemap) {
$uri['path'] = 'sitemap.xml';
$uri['options'] = \Drupal::moduleHandler()->invokeAll('xmlsitemap_context_url_options', [$sitemap->context]);
$context = $sitemap->context;
\Drupal::moduleHandler()->alter('xmlsitemap_context_url_options', $uri['options'], $context);
$uri['options'] += [
'absolute' => TRUE,
'base_url' => Settings::get('xmlsitemap_base_url', \Drupal::state()->get('xmlsitemap_base_url')),
];
return $uri;
}
/**
* @} End of "defgroup xmlsitemap_api"
*/
function xmlsitemap_get_directory(XmlSitemapInterface $sitemap = NULL) {
$directory = &drupal_static(__FUNCTION__);
if (!isset($directory)) {
$directory = \Drupal::config('xmlsitemap.settings')->get('path') ?: 'xmlsitemap';
}
if ($sitemap != NULL && !empty($sitemap->id)) {
return file_build_uri($directory . '/' . $sitemap->id);
}
else {
return file_build_uri($directory);
}
}
/**
* Check that the sitemap files directory exists and is writable.
*/
function xmlsitemap_check_directory(XmlSitemapInterface $sitemap = NULL) {
$directory = xmlsitemap_get_directory($sitemap);
/** @var \Drupal\Core\File\FileSystemInterface $filesystem */
$filesystem = \Drupal::service('file_system');
$result = $filesystem->prepareDirectory($directory, FileSystemInterface::CREATE_DIRECTORY | FileSystemInterface::MODIFY_PERMISSIONS);
if (!$result) {
\Drupal::logger('file system')->error('The directory %directory does not exist or is not writable.', ['%directory' => $directory]);
}
return $result;
}
/**
* Check all directories.
*/
function xmlsitemap_check_all_directories() {
$directories = [];
$sitemaps = xmlsitemap_sitemap_load_multiple(FALSE);
foreach ($sitemaps as $sitemap) {
$directory = xmlsitemap_get_directory($sitemap);
$directories[$directory] = $directory;
}
/** @var \Drupal\Core\File\FileSystemInterface $filesystem */
$filesystem = \Drupal::service('file_system');
foreach ($directories as $directory) {
$result = $filesystem->prepareDirectory($directory, $filesystem::CREATE_DIRECTORY | $filesystem::MODIFY_PERMISSIONS);
if ($result) {
$directories[$directory] = TRUE;
}
else {
$directories[$directory] = FALSE;
}
}
return $directories;
}
/**
* Clears sitemap directory.
*
* @param \Drupal\xmlsitemap\XmlSitemapInterface $sitemap
* Sitemap entity.
* @param bool $delete
* If TRUE, delete the path directory afterwards.
*
* @return bool
* Returns TRUE is operation was successful, FALSE otherwise.
*/
function xmlsitemap_clear_directory(XmlSitemapInterface $sitemap = NULL, $delete = FALSE) {
$directory = xmlsitemap_get_directory($sitemap);
return _xmlsitemap_delete_recursive($directory, $delete);
}
/**
* Move a directory to a new location.
*
* @param string $old_dir
* A string specifying the filepath or URI of the original directory.
* @param string $new_dir
* A string specifying the filepath or URI of the new directory.
* @param int $replace
* Behavior when the destination file already exists.
* Replace behavior when the destination file already exists.
*
* @return bool
* TRUE if the directory was moved successfully. FALSE otherwise.
*/
function xmlsitemap_directory_move($old_dir, $new_dir, $replace = FileSystemInterface::EXISTS_REPLACE) {
/** @var \Drupal\Core\File\FileSystemInterface $filesystem */
$filesystem = \Drupal::service('file_system');
$success = $filesystem->prepareDirectory($new_dir, $filesystem::CREATE_DIRECTORY | $filesystem::MODIFY_PERMISSIONS);
$old_path = $filesystem->realpath($old_dir);
$new_path = $filesystem->realpath($new_dir);
if (!is_dir($old_path) || !is_dir($new_path) || !$success) {
return FALSE;
}
$files = $filesystem->scanDirectory($old_dir, '/.*/');
foreach ($files as $file) {
$file->uri_new = $new_dir . '/' . basename($file->filename);
$success &= (bool) $filesystem->move($file->uri, $file->uri_new, $replace);
}
// The remove the directory.
$success &= $filesystem->rmdir($old_dir);
return $success;
}
/**
* Recursively delete all files and folders in the specified filepath.
*
* This is a backport of Drupal 8's file_unmanaged_delete_recursive().
*
* Note that this only deletes visible files with write permission.
*
* @param string $path
* A filepath relative to the Drupal root directory.
* @param bool $delete_root
* A boolean if TRUE will delete the $path directory afterwards.
*
* @return bool
* TRUE if operation was successful, FALSE otherwise.
*/
function _xmlsitemap_delete_recursive($path, $delete_root = FALSE) {
/** @var \Drupal\Core\File\FileSystemInterface $filesystem */
$filesystem = \Drupal::service('file_system');
// Resolve streamwrapper URI to local path.
$path = $filesystem->realpath($path);
if (is_dir($path)) {
$dir = dir($path);
while (($entry = $dir->read()) !== FALSE) {
if ($entry === '.' || $entry === '..') {
continue;
}
$entry_path = $path . '/' . $entry;
$filesystem->deleteRecursive($entry_path);
}
$dir->close();
return $delete_root ? $filesystem->rmdir($path) : TRUE;
}
return $filesystem->delete($path);
}
/**
* Implements hook_entity_type_build().
*/
function xmlsitemap_entity_type_build(array &$entity_types) {
// Mark some specific core entity types as not supported by XML sitemap.
// If a site wants to undo this, they may use hook_entity_type_alter().
$unsupported_types = [
// Custom blocks.
'block_content',
// Comments.
'comment',
// Shortcut items.
'shortcut',
// Custom Token module.
// @see https://www.drupal.org/project/token_custom/issues/3150038
'token_custom',
];
/** @var $entity_types \Drupal\Core\Entity\EntityTypeInterface[] */
foreach ($unsupported_types as $entity_type_id) {
if (isset($entity_types[$entity_type_id])) {
$entity_types[$entity_type_id]->set('xmlsitemap', FALSE);
}
}
}
/**
* Determines if an entity type can be listed in the XML sitemap as links.
*
* @param \Drupal\Core\Entity\EntityTypeInterface $entity_type
* The entity type.
*
* @return bool
* TRUE if the entity type can be used, or FALSE otherwise.
*/
function xmlsitemap_is_entity_type_supported(EntityTypeInterface $entity_type) {
// If the XML sitemap status in the entity type annotation has been set then
// return that first. This will allow modules to bypass the logic below if
// needed.
$status = $entity_type->get('xmlsitemap');
if ($status !== NULL) {
return $status;
}
// Skip if the entity type is not a content entity type.
if (!($entity_type instanceof ContentEntityTypeInterface)) {
return FALSE;
}
// Skip if the entity type is internal (and not considered public).
if ($entity_type->isInternal()) {
return FALSE;
}
// Skip if the entity type does not have a canonical URL.
if (!$entity_type->hasLinkTemplate('canonical') && !$entity_type->getUriCallback()) {
return FALSE;
}
// Skip if the entity type as a bundle entity type but does not yet have
// any bundles created.
if ($entity_type->getBundleEntityType() && !\Drupal::service('entity_type.bundle.info')->getBundleInfo($entity_type->id())) {
return FALSE;
}
return TRUE;
}
/**
* Returns information about supported sitemap link types.
*
* @param mixed $type
* (optional) The link type to return information for. If omitted,
* information for all link types is returned.
* @param mixed $reset
* (optional) Boolean whether to reset the static cache and do nothing. Only
* used for tests.
*
* @return array
* Info about sitemap link.
*
* @see hook_xmlsitemap_link_info()
* @see hook_xmlsitemap_link_info_alter()
*/
function xmlsitemap_get_link_info($type = NULL, $reset = FALSE) {
$language = \Drupal::languageManager()->getCurrentLanguage();
$link_info = &drupal_static(__FUNCTION__);
if ($reset) {
$link_info = NULL;
\Drupal::service('cache_tags.invalidator')->invalidateTags(['xmlsitemap']);
}
if (!isset($link_info)) {
$cid = 'xmlsitemap:link_info:' . $language->getId();
if ($cache = \Drupal::cache()->get($cid)) {
$link_info = $cache->data;
}
else {
$link_info = [];
$entity_types = \Drupal::entityTypeManager()->getDefinitions();
foreach ($entity_types as $key => $entity_type) {
if (!xmlsitemap_is_entity_type_supported($entity_type)) {
continue;
}
$link_info[$key] = [
'label' => $entity_type->getLabel(),
'type' => $entity_type->id(),
'base table' => $entity_type->getBaseTable(),
'bundles' => \Drupal::service('entity_type.bundle.info')->getBundleInfo($entity_type->id()),
'bundle label' => $entity_type->getBundleLabel(),
'entity keys' => [
'id' => $entity_type->getKey('id'),
'bundle' => $entity_type->getKey('bundle'),
],
'xmlsitemap' => [
// Add in the default callbacks for entity types.
'process callback' => $entity_type->get('xmlsitemap')['process callback'] ?? 'xmlsitemap_xmlsitemap_process_entity_links',
'rebuild callback' => $entity_type->get('xmlsitemap')['process callback'] ?? 'xmlsitemap_rebuild_batch_fetch',
],
];
}
$link_info = array_merge($link_info, \Drupal::moduleHandler()->invokeAll('xmlsitemap_link_info'));
foreach ($link_info as $key => &$info) {
$info += [
'type' => $key,
'base table' => FALSE,
'bundles' => [],
];
foreach ($info['bundles'] as $bundle => &$bundle_info) {
$bundle_info += [
'xmlsitemap' => [],
];
$bundle_info['xmlsitemap'] += xmlsitemap_link_bundle_load($key, $bundle, FALSE);
}
}
\Drupal::moduleHandler()->alter('xmlsitemap_link_info', $link_info);
// Sort the entity types by label.
uasort($link_info, function ($a, $b) {
// Put frontpage first.
if ($a['type'] === 'frontpage') {
return -1;
}
if ($b['type'] === 'frontpage') {
return 1;
}
return strnatcmp($a['label'], $b['label']);
});
// Cache by language since this info contains translated strings.
// Also include entity type tags since this is tied to entity and bundle
// information.
\Drupal::cache()->set(
$cid,
$link_info,
Cache::PERMANENT,
[
'xmlsitemap',
'entity_types',
'entity_bundles',
]
);
}
}
if (isset($type)) {
return isset($link_info[$type]) ? $link_info[$type] : NULL;
}
return $link_info;
}
/**
* Returns enabled bundles of an entity type.
*
* @param string $entity_type
* Entity type id.
*
* @return array
* Array with entity bundles info.
*/
function xmlsitemap_get_link_type_enabled_bundles($entity_type) {
$bundles = [];
$info = xmlsitemap_get_link_info($entity_type);
foreach ($info['bundles'] as $bundle => $bundle_info) {
$settings = xmlsitemap_link_bundle_load($entity_type, $bundle);
if (!empty($settings['status'])) {
$bundles[] = $bundle;
}
}
return $bundles;
}
/**
* Returns statistics about specific entity links.
*
* @param string $entity_type_id
* Entity type id.
* @param string $bundle
* Bundle id.
*
* @return array
* Array with statistics.
*/
function xmlsitemap_get_link_type_indexed_status($entity_type_id, $bundle = '') {
$info = xmlsitemap_get_link_info($entity_type_id);
$database = \Drupal::database();
$entity_type = \Drupal::entityTypeManager()->getDefinition($entity_type_id);
$status['indexed'] = $database->query("SELECT COUNT(id) FROM {xmlsitemap} WHERE type = :entity AND subtype = :bundle", [':entity' => $entity_type_id, ':bundle' => $bundle])->fetchField();
$status['visible'] = $database->query("SELECT COUNT(id) FROM {xmlsitemap} WHERE type = :entity AND subtype = :bundle AND status = 1 AND access = 1", [':entity' => $entity_type_id, ':bundle' => $bundle])->fetchField();
try {
$query = \Drupal::entityQuery($entity_type_id);
if ($bundle && $entity_type->hasKey('bundle')) {
$query->condition($entity_type->getKey('bundle'), $bundle);
}
// We are only using this for totals, so we can skip the access check.
$query->accessCheck(FALSE);
$query->addTag('xmlsitemap_link_indexed_status');
$status['total'] = $query->count()->execute();
return $status;
}
catch (\Exception $e) {
$status['total'] = 0;
}
return $status;
}
/**
* Saves xmlsitemap settings for a specific bundle.
*
* @param string $entity
* Entity type id.
* @param string $bundle
* Bundle id.
* @param array $settings
* Settings to be saved.
* @param bool $update_links
* Update bundle links after settings are saved.
*/
function xmlsitemap_link_bundle_settings_save($entity, $bundle, array $settings, $update_links = TRUE) {
if ($update_links) {
$old_settings = xmlsitemap_link_bundle_load($entity, $bundle);
if ($settings['status'] != $old_settings['status']) {
\Drupal::service('xmlsitemap.link_storage')->updateMultiple(['status' => $settings['status']], [
'type' => $entity,
'subtype' => $bundle,
'status_override' => 0,
]);
}
if ($settings['priority'] != $old_settings['priority']) {
\Drupal::service('xmlsitemap.link_storage')->updateMultiple(['priority' => $settings['priority']], [
'type' => $entity,
'subtype' => $bundle,
'priority_override' => 0,
]);
}
}
foreach ($settings as $key => $value) {
\Drupal::configFactory()->getEditable("xmlsitemap.settings.{$entity}.{$bundle}")->set($key, $value)->save();
}
foreach (\Drupal::languageManager()->getLanguages() as $lang) {
\Drupal::cache()->delete('xmlsitemap:link_info:' . $lang->getId());
}
xmlsitemap_get_link_info(NULL, TRUE);
}
/**
* Renames a bundle.
*
* @param string $entity
* Entity type id.
* @param string $bundle_old
* Old bundle name.
* @param string $bundle_new
* New bundle name.
*/
function xmlsitemap_link_bundle_rename($entity, $bundle_old, $bundle_new) {
if ($bundle_old != $bundle_new) {
if (!\Drupal::config("xmlsitemap.settings.{$entity}.{$bundle_old}")->isNew()) {
$settings = xmlsitemap_link_bundle_load($entity, $bundle_old);
\Drupal::configFactory()->getEditable("xmlsitemap.settings.{$entity}.{$bundle_old}")->delete();
xmlsitemap_link_bundle_settings_save($entity, $bundle_new, $settings, FALSE);
\Drupal::service('xmlsitemap.link_storage')->updateMultiple(['subtype' => $bundle_new], ['type' => $entity, 'subtype' => $bundle_old]);
}
}
}
/**
* Loads link bundle info.
*
* @param string $entity
* Entity type id.
* @param string $bundle
* Bundle info.
* @param bool $load_bundle_info
* If TRUE, loads bundle info.
*
* @return array
* Info about a bundle.
*/
function xmlsitemap_link_bundle_load($entity, $bundle, $load_bundle_info = TRUE) {
$info = [
'entity' => $entity,
'bundle' => $bundle,
];
if ($load_bundle_info) {
$entity_info = xmlsitemap_get_link_info($entity);
if (isset($entity_info['bundles'][$bundle])) {
$info['info'] = $entity_info['bundles'][$bundle];
}
}
$bundle_settings = \Drupal::config("xmlsitemap.settings.{$entity}.{$bundle}")->get();
if ($bundle_settings) {
$info += $bundle_settings;
}
$info += [
'status' => XMLSITEMAP_STATUS_DEFAULT,
'priority' => XMLSITEMAP_PRIORITY_DEFAULT,
'changefreq' => 0,
];
return $info;
}
/**
* Deletes all links of a specific bundle.
*
* @param string $entity
* Entity type id.
* @param string $bundle
* Bundle id.
* @param bool $delete_links
* If TRUE, deletes bundle links from {xmlsitemap} table.
*/
function xmlsitemap_link_bundle_delete($entity, $bundle, $delete_links = TRUE) {
\Drupal::configFactory()->getEditable("xmlsitemap.settings.{$entity}.{$bundle}")->delete();
if ($delete_links) {
\Drupal::service('xmlsitemap.link_storage')->deleteMultiple(['type' => $entity, 'subtype' => $bundle]);
}
xmlsitemap_get_link_info(NULL, TRUE);
}
/**
* Checks access for a bundle.
*
* @param string $entity
* Entity type id.
* @param string $bundle
* Bundle id.
*
* @return bool
* If TRUE, access is allowed, FALSE otherwise.
*/
function xmlsitemap_link_bundle_access($entity, $bundle = NULL) {
if (is_array($entity) && !isset($bundle)) {
$bundle = $entity;
}
else {
$bundle = xmlsitemap_link_bundle_load($entity, $bundle);
}
if (isset($bundle['info']['admin'])) {
$admin = $bundle['info']['admin'];
$admin += ['access arguments' => []];
if (!isset($admin['access callback']) && count($admin['access arguments']) == 1) {
$admin['access callback'] = 'user_access';
}
if (!empty($admin['access callback'])) {
return call_user_func_array($admin['access callback'], $admin['access arguments']);
}
}
return FALSE;
}
/**
* Get path of a bundle.
*
* @param string $entity
* Entity type id.
* @param string $bundle
* Bundle id.
*
* @return mixed
* Path of bundle, or FALSE if it does not exist.
*/
function xmlsitemap_get_bundle_path($entity, $bundle) {
$info = xmlsitemap_get_link_info($entity);
if (!empty($info['bundles'][$bundle]['admin']['real path'])) {
return $info['bundles'][$bundle]['admin']['real path'];
}
elseif (!empty($info['bundles'][$bundle]['admin']['path'])) {
return $info['bundles'][$bundle]['admin']['path'];
}
else {
return FALSE;
}
}
/**
* Implements hook_entity_bundle_rename().
*/
function xmlsitemap_entity_bundle_rename($entity_type_id, $bundle_old, $bundle_new) {
xmlsitemap_link_bundle_rename($entity_type_id, $bundle_old, $bundle_new);
}
/**
* Implements hook_entity_bundle_delete().
*/
function xmlsitemap_entity_bundle_delete($entity_type_id, $bundle) {
xmlsitemap_link_bundle_delete($entity_type_id, $bundle, TRUE);
}
/**
* Determine the frequency of updates to a link.
*
* @param int $interval
* An interval value in seconds.
*
* @return string
* A string representing the update frequency according to the sitemaps.org
* protocol.
*/
function xmlsitemap_get_changefreq($interval) {
if ($interval <= 0 || !is_numeric($interval)) {
return FALSE;
}
foreach (xmlsitemap_get_changefreq_options() as $value => $frequency) {
if ($interval <= $value) {
return $frequency;
}
}
return 'never';
}
/**
* Get the current number of sitemap chunks.
*
* @param int $reset
* If TRUE, reset number of chunks.
*
* @static int $chunks
* Number of chunks.
*
* @return int
* Number of chunks.
*/
function xmlsitemap_get_chunk_count($reset = FALSE) {
static $chunks;
if (!isset($chunks) || $reset) {
$count = max(xmlsitemap_get_link_count($reset), 1);
$chunks = ceil($count / xmlsitemap_get_chunk_size($reset));
}
return $chunks;
}
/**
* Get the current number of sitemap links.
*
* @param bool $reset
* If TRUE, update current number of sitemap links.
*
* @static int $count
* Current number of sitemap links.
*
* @return int
* Returns current number of sitemap links.
*/
function xmlsitemap_get_link_count($reset = FALSE) {
static $count;
if (!isset($count) || $reset) {
$count = \Drupal::database()->query("SELECT COUNT(id) FROM {xmlsitemap} WHERE access = 1 AND status = 1")->fetchField();
}
return $count;
}
/**
* Get the sitemap chunk size.
*
* This function is useful with the chunk size is set to automatic as it will
* calculate the appropriate value. Use this function instead of @code
* xmlsitemap_var('chunk_size') @endcode when the actual value is needed.
*
* @param bool $reset
* A boolean to reset the saved, static result. Defaults to FALSE.
*
* @return int
* An integer with the number of links in each sitemap page.
*/
function xmlsitemap_get_chunk_size($reset = FALSE) {
static $size;
if (!isset($size) || $reset) {
$size = xmlsitemap_var('chunk_size');
if ($size === 'auto') {
// Prevent divide by zero.
$count = max(xmlsitemap_get_link_count($reset), 1);
$size = min(ceil($count / 10000) * 5000, XMLSITEMAP_MAX_SITEMAP_LINKS);
}
}
return $size;
}
/**
* Recalculate the changefreq of a sitemap link.
*
* @param array $link
* A sitemap link array.
*/
function xmlsitemap_recalculate_changefreq(array &$link) {
$time = \Drupal::time()->getRequestTime();
$link['changefreq'] = round((($link['changefreq'] * $link['changecount']) + ($time - $link['lastmod'])) / ($link['changecount'] + 1));
$link['changecount']++;
$link['lastmod'] = $time;
}
/**
* Calculates the average interval between UNIX timestamps.
*
* @param array $timestamps
* An array of UNIX timestamp integers.
*
* @return int
* An integer of the average interval.
*/
function xmlsitemap_calculate_changefreq(array $timestamps) {
sort($timestamps);
$count = count($timestamps) - 1;
$diff = 0;
for ($i = 0; $i < $count; $i++) {
$diff += $timestamps[$i + 1] - $timestamps[$i];
}
return $count > 0 ? round($diff / $count) : 0;
}
/**
* Submit handler; Set the regenerate needed flag if variables have changed.
*
* This function needs to be called before system_settings_form_submit() or any
* calls to variable_set().
*/
function xmlsitemap_form_submit_flag_regenerate(array $form, FormStateInterface $form_state) {
$values = $form_state->getValues();
foreach ($values as $variable => $value) {
if (\Drupal::config('xmlsitemap.settings')->get($variable) == NULL) {
$stored_value = 'not_a_variable';
}
else {
$stored_value = \Drupal::config('xmlsitemap.settings')->get($variable);
}
if (is_array($value) && !$form_state->isValueEmpty('array_filter')) {
$value = array_keys(array_filter($value));
}
if ($stored_value != 'not_a_variable' && $stored_value != $value) {
\Drupal::state()->set('xmlsitemap_regenerate_needed', TRUE);
\Drupal::messenger()->addWarning(t('XML sitemap settings have been modified and the files should be regenerated. You can <a href="@run-cron">run cron manually</a> to regenerate the cached files.', [
'@run-cron' => Url::fromRoute('system.run_cron', [], ['query' => \Drupal::destination()->getAsArray()])->toString(),
]), FALSE);
return;
}
}
}
/**
* Add a link's XML sitemap options to the link's form.
*
* @param array $form
* Form array.
* @param string $entity
* Entity type id.
* @param string $bundle
* Bundle id.
* @param int $id
* Entity id.
*
* @todo Add changefreq overridability.
*/
function xmlsitemap_add_form_link_options(array &$form, $entity, $bundle, $id) {
$info = xmlsitemap_get_link_info($entity);
if (!$link = \Drupal::service('xmlsitemap.link_storage')->load($entity, $id)) {
$link = [];
}
$bundle_info = xmlsitemap_link_bundle_load($entity, $bundle);
$link += [
'access' => 1,
'status' => $bundle_info['status'],
'status_default' => $bundle_info['status'],
'status_override' => 0,
'priority' => $bundle_info['priority'],
'priority_default' => $bundle_info['priority'],
'priority_override' => 0,
'changefreq' => $bundle_info['changefreq'],
];
$currentUser = \Drupal::currentUser();
$form['xmlsitemap'] = [
'#type' => 'details',
'#tree' => TRUE,
'#title' => t('XML sitemap'),
'#collapsible' => TRUE,
'#collapsed' => !$link['status_override'] && !$link['priority_override'],
'#access' => $currentUser->hasPermission('administer xmlsitemap') || xmlsitemap_link_bundle_access($bundle_info),
'#group' => 'advanced',
];
if (xmlsitemap_link_bundle_access($bundle_info) && $path = xmlsitemap_get_bundle_path($entity, $bundle)) {
$form['xmlsitemap']['description'] = [
'#prefix' => '<div class="description">',
'#suffix' => '</div>',
'#markup' => t('The default XML sitemap settings for this @bundle can be changed <a href="@link-type">here</a>.', [
'@bundle' => mb_strtolower($info['bundle label']),
'@link-type' => Url::fromUri($path, ['query' => \Drupal::destination()->getAsArray()])->toString(),
]),
];
}
// Show a warning if the link is not accessible and will not be included in
// the sitemap.
if ($id && !$link['access']) {
$form['xmlsitemap']['warning'] = [
'#type' => 'markup',
'#prefix' => '<p><strong>',
'#suffix' => '</strong></p>',
'#value' => ('This item is not currently visible to anonymous users, so it will not be included in the sitemap.'),
];
}
// Status field (inclusion/exclusion)
$form['xmlsitemap']['status'] = [
'#type' => 'select',
'#title' => t('Inclusion'),
'#options' => xmlsitemap_get_status_options($link['status_default']),
'#default_value' => $link['status_override'] ? $link['status'] : 'default',
];
$form['xmlsitemap']['status_default'] = [
'#type' => 'value',
'#value' => $link['status_default'],
];
$form['xmlsitemap']['status_override'] = [
'#type' => 'value',
'#value' => $link['status_override'],
];
// Priority field.
$form['xmlsitemap']['priority'] = [
'#type' => 'select',
'#title' => t('Priority'),
'#options' => xmlsitemap_get_priority_options($link['priority_default']),
'#default_value' => $link['priority_override'] ? number_format($link['priority'], 1) : 'default',
'#description' => t('The priority of this URL relative to other URLs on your site.'),
'#states' => [
'invisible' => [
'select[name="xmlsitemap[status]"]' => ['value' => '0'],
],
],
];
$form['xmlsitemap']['changefreq'] = [
'#type' => 'select',
'#title' => t('Change frequency'),
'#options' => xmlsitemap_get_changefreq_options(),
'#default_value' => $link['changefreq'],
'#description' => t('Select the frequency of changes.'),
'#states' => [
'invisible' => [
'select[name="xmlsitemap[status]"]' => ['value' => '0'],
],
],
];
if (!$link['status_default']) {
// If the default status is excluded, add a visible state on the include
// override option.
$form['xmlsitemap']['priority']['#states']['visible'] = [
'select[name="xmlsitemap[status]"]' => ['value' => '1'],
];
}
$form['xmlsitemap']['priority_default'] = [
'#type' => 'value',
'#value' => $link['priority_default'],
];
$form['xmlsitemap']['priority_override'] = [
'#type' => 'value',
'#value' => $link['priority_override'],
];
array_unshift($form['actions']['submit']['#submit'], 'xmlsitemap_process_form_link_options');
if (!empty($form['actions']['publish']['#submit'])) {
array_unshift($form['actions']['publish']['#submit'], 'xmlsitemap_process_form_link_options');
}
}
/**
* Submit callback for the entity form to save.
*/
function xmlsitemap_process_form_link_options(array $form, FormStateInterface $form_state) {
$link = $form_state->getValue('xmlsitemap');
$fields = ['status' => XMLSITEMAP_STATUS_DEFAULT, 'priority' => XMLSITEMAP_PRIORITY_DEFAULT];
foreach ($fields as $field => $default) {
if ($link[$field] === 'default') {
$link[$field] = isset($link[$field . '_default']) ? $link[$field . '_default'] : $default;
$link[$field . '_override'] = 0;
}
else {
$link[$field . '_override'] = 1;
}
}
$form_state->setValue('xmlsitemap', $link);
$entity = $form_state->getFormObject()->getEntity();
$entity->xmlsitemap = $form_state->getValue('xmlsitemap');
}
/**
* Submit callback for link bundle settings.
*/
function xmlsitemap_link_bundle_settings_form_submit($form, &$form_state) {
$entity = $form['xmlsitemap']['#entity'];
$bundle = $form['xmlsitemap']['#bundle'];
// Handle new bundles by fetching the proper bundle key value from the form
// state values.
if (empty($bundle)) {
$entity_info = $form['xmlsitemap']['#entity_info'];
if (isset($entity_info['bundle keys']['bundle'])) {
$bundle_key = $entity_info['bundle keys']['bundle'];
if ($form_state->hasValue($bundle_key)) {
$bundle = $form_state->getValue($bundle_key);
$form['xmlsitemap']['#bundle'] = $bundle;
}
}
}
xmlsitemap_link_bundle_settings_save($entity, $bundle, $form_state->getValue('xmlsitemap'));
$entity_info = $form['xmlsitemap']['#entity_info'];
if (!empty($form['xmlsitemap']['#show_message'])) {
\Drupal::messenger()->addStatus(t('XML sitemap settings for the @bundle-label %bundle have been saved.', ['@bundle-label' => mb_strtolower($entity_info['bundle label']), '%bundle' => $entity_info['bundles'][$bundle]['label']]));
}
// Unset the form values since we have already saved the bundle settings and
// we don't want these values to get saved as variables in-case this form
// also uses system_settings_form().
$form_state->unsetValue('xmlsitemap');
}
/**
* Gets xmlsitemap frequency options.
*
* @return array
* Frequency options.
*
* @todo Document this function.
* @todo Make these translatable
*/
function xmlsitemap_get_changefreq_options() {
return [
XMLSITEMAP_FREQUENCY_ALWAYS => 'always',
XMLSITEMAP_FREQUENCY_HOURLY => 'hourly',
XMLSITEMAP_FREQUENCY_DAILY => 'daily',
XMLSITEMAP_FREQUENCY_WEEKLY => 'weekly',
XMLSITEMAP_FREQUENCY_MONTHLY => 'monthly',
XMLSITEMAP_FREQUENCY_YEARLY => 'yearly',
];
}
/**
* Load a language object by its language code.
*
* @param string $language
* A language code. If not provided the default language will be returned.
*
* @return \Drupal\core\Language\LanguageInterface
* A language object.
*
* @todo Remove when https://www.drupal.org/node/660736 is fixed in Drupal core.
*/
function xmlsitemap_language_load($language = LanguageInterface::LANGCODE_NOT_SPECIFIED) {
$languages = &drupal_static(__FUNCTION__);
if (!isset($languages)) {
$languages = \Drupal::languageManager()->getLanguages();
$languages[LanguageInterface::LANGCODE_NOT_SPECIFIED] = NULL;
}
return isset($languages[$language]) ? $languages[$language] : NULL;
}
/**
* @defgroup xmlsitemap_context_api XML sitemap API for sitemap contexts.
* @{
*/
/**
* Gets info about a context.
*
* @param string $context
* The context.
* @param bool $reset
* If TRUE, resets context info.
*
* @return array
* Array with info.
*/
function xmlsitemap_get_context_info($context = NULL, $reset = FALSE) {
$language = \Drupal::languageManager()->getCurrentLanguage();
$info = &drupal_static(__FUNCTION__);
if ($reset) {
$info = NULL;
}
elseif ($cached = \Drupal::cache()->get('xmlsitemap:context_info:' . $language->getId())) {
$info = $cached->data;
}
if (!isset($info)) {
$info = \Drupal::moduleHandler()->invokeAll('xmlsitemap_context_info');
\Drupal::moduleHandler()->alter('xmlsitemap_context_info', $info);
ksort($info);
// Cache by language since this info contains translated strings.
\Drupal::cache()->set('xmlsitemap:context_info:' . $language->getId(), $info, Cache::PERMANENT, ['xmlsitemap']);
}
if (isset($context)) {
return isset($info[$context]) ? $info[$context] : NULL;
}
return $info;
}
/**
* Get the sitemap context of the current request.
*
* @return array
* Current context.
*/
function xmlsitemap_get_current_context() {
$context = &drupal_static(__FUNCTION__);
if (!isset($context)) {
$context = \Drupal::moduleHandler()->invokeAll('xmlsitemap_context');
\Drupal::moduleHandler()->alter('xmlsitemap_context', $context);
ksort($context);
}
return $context;
}
/**
* Gets summary about a context.
*
* @param \Drupal\xmlsitemap\XmlSitemapInterface $sitemap
* Sitemap entity.
* @param string $context_key
* Key for the context.
* @param array $context_info
* Info about the context.
*
* @return string
* Context summary.
*/
function _xmlsitemap_sitemap_context_summary(XmlSitemapInterface $sitemap, $context_key, array $context_info) {
$context_value = isset($sitemap->context[$context_key]) ? $sitemap->context[$context_key] : NULL;
if (!isset($context_value)) {
return t('Default');
}
elseif (!empty($context_info['summary callback'])) {
return $context_info['summary callback']($context_value);
}
else {
return $context_value;
}
}
/**
* @} End of "defgroup xmlsitemap_context_api"
*/
/**
* Run a not-progressive batch operation.
*/
function xmlsitemap_run_unprogressive_batch() {
$batch = batch_get();
$lock = \Drupal::lock();
if (!empty($batch)) {
// If there is already something in the batch, don't run.
return FALSE;
}
$args = func_get_args();
$batch_callback = array_shift($args);
if (!$lock->acquire($batch_callback)) {
return FALSE;
}
// Attempt to increase the execution time.
Environment::setTimeLimit(240);
// Build the batch array.
$batch = call_user_func_array($batch_callback, $args);
batch_set($batch);
// We need to manually set the progressive variable again.
// @todo Remove when https://www.drupal.org/node/638712 is fixed.
$batch = & batch_get();
$batch['progressive'] = FALSE;
// Run the batch process.
if (PHP_SAPI === 'cli' && function_exists('drush_backend_batch_process')) {
drush_backend_batch_process();
}
else {
batch_process();
}
$lock->release($batch_callback);
return TRUE;
}
/**
* Gets a link from url.
*
* @param string $url
* Url of the link.
* @param array $options
* Extra options of the url such as 'query'.
*
* @static string $destination
* Destination option.
*
* @return array
* An array representing a link.
*/
function xmlsitemap_get_operation_link($url, array $options = []) {
static $destination;
if (!isset($destination)) {
$destination = \Drupal::destination()->getAsArray();
}
$link = ['href' => $url] + $options;
$link += ['query' => $destination];
return $link;
}
/**
* Returns HTML for an administration settings table.
*
* @param array $variables
* An associative array containing:
* - build: A render element representing a table of bundle content language
* settings for a particular entity type.
*
* @return string
* HTML content.
*
* @ingroup themable
*/
function theme_xmlsitemap_content_settings_table(array $variables) {
return '<h4>' . $variables['build']['#title'] . '</h4>' . \Drupal::service('renderer')->render($variables['build']);
}
/**
* Implements hook_form_alter().
*/
function xmlsitemap_form_alter(array &$form, FormStateInterface $form_state, $form_id) {
$form_object = $form_state->getFormObject();
if ($form_object instanceof ContentEntityFormInterface) {
$entity = $form_object->getEntity();
// Some entity types use 'default' for add/edit forms.
$operations = ['default', 'edit'];
if ($entity->getEntityTypeId() === 'user') {
$operations[] = 'register';
}
if (in_array($form_object->getOperation(), $operations, TRUE) && xmlsitemap_link_bundle_check_enabled($entity->getEntityTypeId(), $entity->bundle())) {
xmlsitemap_add_form_link_options($form, $entity->getEntityTypeId(), $entity->bundle(), $entity->id());
$form['xmlsitemap']['#weight'] = 10;
}
}
}
/**
* Implements hook_xmlsitemap_index_links().
*/
function xmlsitemap_xmlsitemap_index_links($limit) {
$entity_type_manager = \Drupal::entityTypeManager();
$entity_types = $entity_type_manager->getDefinitions();
foreach ($entity_types as $entity_type_id => $entity_type) {
// If an entity type is not supported it will not have link info.
$info = xmlsitemap_get_link_info($entity_type_id);
if (empty($info)) {
continue;
}
$bundles = xmlsitemap_get_link_type_enabled_bundles($entity_type_id);
if (empty($bundles)) {
continue;
}
try {
$query = $entity_type_manager->getStorage($entity_type_id)->getQuery();
$query->range(0, $limit);
if (!empty($info['entity keys']['bundle'])) {
$query->condition($info['entity keys']['bundle'], $bundles, 'IN');
}
// Perform a subquery against the xmlsitemap table to ensure that we are
// only looking for items that we have not already indexed.
$subquery = \Drupal::database()->select('xmlsitemap', 'x');
$subquery->addField('x', 'id');
$subquery->condition('type', $entity_type_id);
// If the storage for this entity type is against a SQL backend, perform
// a direct subquery condition to avoid needing to load all the IDs.
if ($query instanceof \Drupal\Core\Entity\Query\Sql\Query) {
$query->condition($info['entity keys']['id'], $subquery, 'NOT IN');
}
else {
$query->condition($info['entity keys']['id'], $subquery->execute()->fetchCol(), 'NOT IN');
}
// Access for entities is checked individually for the anonymous user
// when each item is processed. We can skip the access check for the
// query.
$query->accessCheck(FALSE);
$query->addTag('xmlsitemap_index_links');
if ($ids = $query->execute()) {
// Chunk the array into batch sizes.
$chunks = array_chunk($ids, \Drupal::config('xmlsitemap.settings')->get('batch_limit'));
foreach ($chunks as $chunk) {
$info['xmlsitemap']['process callback']($entity_type_id, $chunk);
}
\Drupal::logger('xmlsitemap')->info('Indexed @count new @type items.', [
'@count' => count($ids),
'@type' => $entity_type_id
]);
}
}
catch (\Exception $e) {
watchdog_exception('xmlsitemap', $e);
}
}
}
/**
* Process sitemap links.
*
* @param string $entity_type_id
* The entity type to process.
* @param array $entity_ids
* Entity IDs to be processed.
*/
function xmlsitemap_xmlsitemap_process_entity_links($entity_type_id, array $entity_ids) {
/** @var \Drupal\Core\Entity\ContentEntityInterface[] $entities */
$entities = \Drupal::entityTypeManager()->getStorage($entity_type_id)->loadMultiple($entity_ids);
foreach ($entities as $entity) {
xmlsitemap_xmlsitemap_process_entity_link($entity);
}
// Reset the entity cache afterwards to clear out some memory.
\Drupal::entityTypeManager()->getStorage($entity_type_id)->resetCache();
}
/**
* Process sitemap link for an entity.
*
* @param \Drupal\Core\Entity\EntityInterface $entity
* The entity object.
*/
function xmlsitemap_xmlsitemap_process_entity_link(EntityInterface $entity) {
/** @var \Drupal\xmlsitemap\XmlSitemapLinkStorageInterface $link_storage */
$link_storage = \Drupal::service('xmlsitemap.link_storage');
if ($entity instanceof ContentEntityInterface) {
// Generate an entry for each translation.
$translation_languages = $entity->getTranslationLanguages();
foreach ($translation_languages as $langcode => $language) {
$translation = $entity->getTranslation($langcode);
$link = $link_storage->create($translation);
$context = [$link['type'] => $entity, 'entity' => $entity];
$link_storage->save($link, $context);
}
// Check if there are any removed language translations.
if (isset($entity->original)) {
$original_translation_languages = $entity->original->getTranslationLanguages();
$removed_translation_languages = array_diff(array_keys($original_translation_languages), array_keys($translation_languages));
if (!empty($removed_translation_languages)) {
$link_storage->deleteMultiple([
'type' => $entity->getEntityTypeId(),
'id' => $entity->id(),
'language' => $removed_translation_languages,
]);
}
}
}
else {
$link = $link_storage->create($entity);
$context = [$link['type'] => $entity, 'entity' => $entity];
$link_storage->save($link, $context);
}
}
/**
* Implements hook_entity_insert().
*/
function xmlsitemap_entity_insert(EntityInterface $entity) {
if (xmlsitemap_link_bundle_check_enabled($entity->getEntityTypeId(), $entity->bundle())) {
xmlsitemap_xmlsitemap_process_entity_link($entity);
}
}
/**
* Implements hook_entity_update().
*/
function xmlsitemap_entity_update(EntityInterface $entity) {
if (xmlsitemap_link_bundle_check_enabled($entity->getEntityTypeId(), $entity->bundle())) {
xmlsitemap_xmlsitemap_process_entity_link($entity);
}
}
/**
* Implements hook_entity_delete().
*/
function xmlsitemap_entity_delete(EntityInterface $entity) {
$langcode = $entity->language() ? $entity->language()->getId() : NULL;
\Drupal::service('xmlsitemap.link_storage')->delete($entity->getEntityTypeId(), $entity->id(), $langcode);
}
/**
* Implements hook_entity_translation_delete().
*/
function xmlsitemap_entity_translation_delete(EntityInterface $translation) {
\Drupal::service('xmlsitemap.link_storage')->delete($translation->getEntityTypeId(), $translation->id(), $translation->language()->getId());
}
/**
* Implements hook_xmlsitemap_context_info() for language module.
*/
function language_xmlsitemap_context_info() {
$context['language'] = [
'label' => t('Language'),
'summary callback' => 'language_name',
'default' => \Drupal::languageManager()->getDefaultLanguage()->getId(),
];
return $context;
}
/**
* Implements hook_xmlsitemap_context() for language module.
*/
function language_xmlsitemap_context() {
$language = \Drupal::languageManager()->getCurrentLanguage();
$context['language'] = $language->getId();
return $context;
}
/**
* Implements hook_xmlsitemap_context_url_options() for language module.
*/
function language_xmlsitemap_context_url_options(array $context) {
$options = [];
if (isset($context['language'])) {
$options['language'] = xmlsitemap_language_load($context['language']);
}
return $options;
}
/**
* Implements hook_form_FORM_ID_alter() for language module.
*/
function language_form_xmlsitemap_sitemap_edit_form_alter(&$form, FormStateInterface $form_state) {
$options = [];
$languages = \Drupal::languageManager()->getLanguages();
foreach ($languages as $language_key => $language) {
$options[$language_key] = $language->getName();
}
$form['context']['language'] = [
'#type' => 'select',
'#title' => t('Language'),
'#options' => $options,
'#default_value' => isset($form['#entity']->context['language']) ? $form['#entity']->context['language'] : \Drupal::languageManager()->getDefaultLanguage()->getId(),
'#description' => t('Most sites should only need a sitemap for their default language since translated content is now added to the sitemap using alternate links. If you truly need a sitemap for multiple languages, it is still possible to do so.'),
];
}
/**
* Implements hook_form_FORM_ID_alter().
*
* Set the regeneration needed flag if settings are changed.
*/
function xmlsitemap_form_language_admin_overview_form_alter(&$form, FormStateInterface $form_state) {
array_unshift($form['#submit'], 'xmlsitemap_form_submit_flag_regenerate');
}
/**
* Implements hook_query_TAG_alter() for language module.
*/
function language_query_xmlsitemap_generate_alter(AlterableInterface $query) {
$mode = \Drupal::config('xmlsitemap.settings')->get('i18n_selection_mode') ?: 'simple';
if ($mode === 'off') {
return;
}
/** @var \Drupal\xmlsitemap\XmlSitemapInterface $sitemap */
$sitemap = $query->getMetaData('sitemap');
// Get languages to simplify query building.
$default = \Drupal::languageManager()->getDefaultLanguage()->getId();
$current = isset($sitemap->context['language']) ? $sitemap->context['language'] : $default;
if ($mode == 'mixed' && $current == $default) {
// If mode is mixed but current = default, is the same as 'simple'.
$mode = 'simple';
}
switch ($mode) {
case 'simple':
// Current language and language neutral.
$query->condition('language', [
$current, LanguageInterface::LANGCODE_NOT_SPECIFIED,
], 'IN');
break;
case 'mixed':
// Mixed current language (if available) or default language (if not) and
// language neutral.
$query->condition('language', [
$current, $default, LanguageInterface::LANGCODE_NOT_SPECIFIED,
], 'IN');
break;
case 'default':
// Only default language and language neutral.
$query->condition('language', [$default, LanguageInterface::LANGCODE_NOT_SPECIFIED], 'IN');
break;
case 'strict':
// Only current language (for nodes), simple for all other types.
$node_condition = new Condition('AND');
$node_condition->condition('type', 'node', '=');
$node_condition->condition('language', $current, '=');
$normal_condition = new Condition('AND');
$normal_condition->condition('type', 'node', '<>');
$normal_condition->condition('language', [$current, LanguageInterface::LANGCODE_NOT_SPECIFIED], 'IN');
$condition = new Condition('OR');
$condition->condition($node_condition);
$condition->condition($normal_condition);
$query->condition($condition);
break;
case 'off':
// All content. No language conditions apply.
break;
}
}
/**
* Implements hook_xmlsitemap_element_alter() for language module.
*/
function language_xmlsitemap_element_alter(array &$element, array $link, XmlSitemapInterface $sitemap) {
// Add alternate links for each language for generic links.
if ($link['langcode'] === LanguageInterface::LANGCODE_NOT_SPECIFIED) {
$languages = \Drupal::languageManager()->getLanguages();
unset($languages[$sitemap->context['language']]);
foreach ($languages as $language) {
_xmlsitemap_element_add_alternate_lang($element, $link['loc'], $language, $sitemap);
}
}
}
/**
* Implements hook_xmlsitemap_element_alter() for content_translation module.
*/
function content_translation_xmlsitemap_element_alter(array &$element, array $link, XmlSitemapInterface $sitemap) {
if ($link['langcode'] === LanguageInterface::LANGCODE_NOT_SPECIFIED) {
return;
}
// @todo Cache this information longer than a static method.
$loc_whitelist = &drupal_static(__FUNCTION__);
if (!isset($loc_whitelist)) {
$loc_whitelist = FALSE;
if ($types = array_keys(\Drupal::service('content_translation.manager')->getSupportedEntityTypes())) {
$query = \Drupal::database()->select('xmlsitemap', 'x');
$query->distinct(TRUE);
$query->addExpression('SUBSTRING_INDEX(x.loc, :slash, 2)', 'path', [':slash' => '/']);
$query->condition('x.type', $types, 'IN');
$whitelist_paths = $query->execute()->fetchCol();
$loc_whitelist = '/^(' . implode('|', array_map(function ($path) {
return preg_quote($path . '/', '/') . '.*';
}, $whitelist_paths)) . ')/';
}
}
if ($loc_whitelist && preg_match($loc_whitelist, $link['loc'])) {
$query = \Drupal::database()->select('xmlsitemap', 'x');
$query->fields('x', ['loc', 'language']);
$query->condition('x.loc', $link['loc']);
$query->condition('x.language', [$link['langcode'], LanguageInterface::LANGCODE_NOT_SPECIFIED], 'NOT IN');
$query->condition('x.access', 1);
$query->condition('x.status', 1);
$language_links = $query->execute();
while ($language_link = $language_links->fetchAssoc()) {
_xmlsitemap_element_add_alternate_lang($element, $language_link['loc'], xmlsitemap_language_load($language_link['language']), $sitemap);
}
}
}
/**
* Adds alternate language links to a sitemap element.
*
* @param array $element
* The sitemap element from hook_xmlsitemap_element_alter().
* @param string $loc
* The location for the URL.
* @param \Drupal\Core\Language\LanguageInterface $language
* The alternate language.
* @param \Drupal\xmlsitemap\XmlSitemapInterface $sitemap
* The current sitemap being generated for the element.
*
* @internal
*/
function _xmlsitemap_element_add_alternate_lang(array &$element, $loc, LanguageInterface $language, XmlSitemapInterface $sitemap) {
$url_options = $sitemap->uri['options'];
$url_options += [
'absolute' => TRUE,
'base_url' => rtrim(Settings::get('xmlsitemap_base_url', \Drupal::state()->get('xmlsitemap_base_url')), '/'),
'alias' => FALSE,
];
$alternate_href = Url::fromUri('internal:' . $loc, ['language' => $language] + $url_options)->toString();
if ($alternate_href !== $element['loc']) {
$element[] = [
'key' => 'xhtml:link',
'attributes' => [
'rel' => 'alternate',
'hreflang' => $language->getId(),
'href' => $alternate_href,
],
];
}
}
/**
* Implements hook_xmlsitemap_link_info().
*/
function xmlsitemap_xmlsitemap_link_info() {
return [
'frontpage' => [
'label' => t('Frontpage'),
'xmlsitemap' => [
'settings callback' => 'xmlsitemap_link_frontpage_settings',
],
],
];
}
/**
* Implements hook_xmlsitemap_link_alter().
*/
function xmlsitemap_xmlsitemap_link_alter(&$link) {
// Alter the frontpage priority.
if ($link['type'] == 'frontpage' || $link['loc'] == '/' || $link['loc'] == Drupal::config('system.site')->get('page.front')) {
$link['priority'] = \Drupal::config('xmlsitemap.settings')->get('frontpage_priority');
$link['changefreq'] = \Drupal::config('xmlsitemap.settings')->get('frontpage_changefreq');
}
}
/**
* Implements hook_xmlsitemap_links().
*/
function xmlsitemap_xmlsitemap_links() {
// Frontpage link.
$links[] = [
'type' => 'frontpage',
'id' => 0,
'loc' => '/',
];
return $links;
}
/**
* Implements hook_xmlsitemap_sitemap_operations().
*/
function xmlsitemap_xmlsitemap_sitemap_operations() {
$operations['update'] = [
'label' => t('Update cached files'),
'action past' => t('Updated'),
'callback' => 'xmlsitemap_sitemap_multiple_update',
];
return $operations;
}
/**
* XML sitemap link type settings callback for frontpage link entity.
*
* @param array $form
* Form array.
*
* @return array
* Updated form.
*/
function xmlsitemap_link_frontpage_settings(array &$form) {
if (\Drupal::currentUser()->hasPermission('administer site configuration')) {
$form['#description'] = t('The front page path can be changed in the <a href="@url-frontpage">site information configuration</a>.', ['@url-frontpage' => Url::fromRoute('system.site_information_settings')->toString()]);
}
$form['frontpage_priority'] = [
'#type' => 'select',
'#title' => t('Priority'),
'#options' => xmlsitemap_get_priority_options(),
'#default_value' => \Drupal::config('xmlsitemap.settings')->get('frontpage_priority'),
];
$form['frontpage_changefreq'] = [
'#type' => 'select',
'#title' => t('Change frequency'),
'#options' => xmlsitemap_get_changefreq_options(),
'#default_value' => \Drupal::config('xmlsitemap.settings')->get('frontpage_changefreq'),
];
return $form;
}
/**
* XML sitemap operation callback; regenerate sitemap files using the batch API.
*
* @param array $smids
* An array of XML sitemap IDs.
*
* @see xmlsitemap_regenerate_batch()
*/
function xmlsitemap_sitemap_multiple_update(array $smids) {
$batch = xmlsitemap_regenerate_batch($smids);
batch_set($batch);
}
/**
* Add a table summary for an entity and its bundles.
*
* @param array $form
* Form array.
* @param string $entity
* Entity type id.
* @param array $entity_info
* Info about the entity type.
*/
function xmlsitemap_add_form_entity_summary(array &$form, $entity, array $entity_info) {
$priorities = xmlsitemap_get_priority_options(NULL, FALSE);
$statuses = xmlsitemap_get_status_options(NULL);
$rows = [];
$totals = ['total' => 0, 'indexed' => 0, 'visible' => 0];
foreach ($entity_info['bundles'] as $bundle => $bundle_info) {
// Fetch current per-bundle link total and indexed counts.
if (!xmlsitemap_link_bundle_check_enabled($entity, $bundle)) {
continue;
}
$status = xmlsitemap_get_link_type_indexed_status($entity, $bundle);
$totals['total'] += $status['total'];
$totals['indexed'] += $status['indexed'];
$totals['visible'] += $status['visible'];
$rows[] = [
Link::createFromRoute($bundle_info['label'], 'xmlsitemap.admin_settings_bundle', ['entity' => $entity, 'bundle' => $bundle]),
$statuses[$bundle_info['xmlsitemap']['status'] ? 1 : 0],
$priorities[number_format($bundle_info['xmlsitemap']['priority'], 1)],
$status['total'],
$status['indexed'],
$status['visible'],
];
}
if ($rows) {
$header = [
isset($entity_info['bundle label']) ? $entity_info['bundle label'] : '',
t('Inclusion'),
t('Priority'),
t('Available'),
t('Indexed'),
t('Visible'),
];
$rows[] = [
[
'data' => t('Totals'),
'colspan' => 3,
'header' => TRUE,
],
[
'data' => $totals['total'],
'header' => TRUE,
],
[
'data' => $totals['indexed'],
'header' => TRUE,
],
[
'data' => $totals['visible'],
'header' => TRUE,
],
];
$form['summary'] = [
'#theme' => 'table',
'#header' => $header,
'#rows' => $rows,
];
}
}
/**
* Add the link type XML sitemap options to the link type's form.
*
* Caller is responsible for ensuring xmlsitemap_link_bundle_settings_save()
* is called during submission.
*
* @param array $form
* Form array.
* @param Drupal\Core\Form\FormStateInterface $form_state
* Form state array.
* @param string $entity
* Entity type id.
* @param string $bundle
* Bundle id.
*/
function xmlsitemap_add_link_bundle_settings(array &$form, FormStateInterface $form_state, $entity, $bundle) {
$entity_info = xmlsitemap_get_link_info($entity);
$bundle_info = xmlsitemap_link_bundle_load($entity, $bundle);
$form['xmlsitemap'] = [
'#type' => 'details',
'#title' => t('XML sitemap'),
'#collapsible' => TRUE,
'#collapsed' => TRUE,
'#access' => \Drupal::currentUser()->hasPermission('administer xmlsitemap'),
'#group' => 'advanced',
'#tree' => TRUE,
'#entity' => $entity,
'#bundle' => $bundle,
'#entity_info' => $entity_info,
'#bundle_info' => $bundle_info,
];
$form['xmlsitemap']['description'] = [
'#prefix' => '<div class="description">',
'#suffix' => '</div>',
'#markup' => t('Changing these type settings will affect any items of this type that have either inclusion or priority set to default.'),
];
$form['xmlsitemap']['status'] = [
'#type' => 'select',
'#title' => t('Inclusion'),
'#options' => xmlsitemap_get_status_options(),
'#default_value' => (int) $bundle_info['status'],
];
$form['xmlsitemap']['priority'] = [
'#type' => 'select',
'#title' => t('Default priority'),
'#options' => xmlsitemap_get_priority_options(),
'#default_value' => $bundle_info['priority'],
'#states' => [
'invisible' => [
'select[name="xmlsitemap[status]"]' => ['value' => '0'],
],
],
];
$form['xmlsitemap']['changefreq'] = [
'#type' => 'select',
'#title' => t('Default change frequency'),
'#options' => xmlsitemap_get_changefreq_options(),
'#default_value' => $bundle_info['changefreq'],
'#states' => [
'invisible' => [
'select[name="xmlsitemap[status]"]' => ['value' => '0'],
],
],
];
}
/**
* Get a list of priority options.
*
* @param string $default
* Include a 'default' option.
* @param bool $guides
* Add helpful indicators for the highest, middle and lowest values.
*
* @return array
* An array of options.
*/
function xmlsitemap_get_priority_options($default = NULL, $guides = TRUE) {
$options = [];
$priorities = [
'1.0' => t('1.0'),
'0.9' => t('0.9'),
'0.8' => t('0.8'),
'0.7' => t('0.7'),
'0.6' => t('0.6'),
'0.5' => t('0.5'),
'0.4' => t('0.4'),
'0.3' => t('0.3'),
'0.2' => t('0.2'),
'0.1' => t('0.1'),
'0.0' => t('0.0'),
];
if (isset($default)) {
$default = number_format($default, 1);
$options['default'] = t('Default (@value)', ['@value' => $priorities[$default]]);
}
// Add the rest of the options.
$options += $priorities;
if ($guides) {
$options['1.0'] .= ' ' . t('(highest)');
$options['0.5'] .= ' ' . t('(normal)');
$options['0.0'] .= ' ' . t('(lowest)');
}
return $options;
}
/**
* Get a list of priority options.
*
* @param string $default
* Include a 'default' option.
*
* @return array
* An array of options.
*
* @see _xmlsitemap_translation_strings()
*/
function xmlsitemap_get_status_options($default = NULL) {
$options = [];
$statuses = [
1 => t('Included'),
0 => t('Excluded'),
];
if (isset($default)) {
$default = $default ? 1 : 0;
$options['default'] = t('Default (@value)', ['@value' => mb_strtolower($statuses[$default])]);
}
$options += $statuses;
return $options;
}
/**
* Get the sitemap chunk/page of the current request.
*
* @param \Drupal\xmlsitemap\XmlSitemapInterface $sitemap
* Sitemap entity.
* @param \Symfony\Component\HttpFoundation\Request $request
* The request to use if provided, otherwise \Drupal::request() will be used.
*
* @return int|string
* Returns current chunk of the sitemap.
*/
function xmlsitemap_get_current_chunk(XmlSitemapInterface $sitemap, Request $request = NULL) {
if (!isset($request)) {
$request = \Drupal::request();
}
// Check if we should display the index.
$query = $request->query;
$query_page = $query->get('page');
if (!isset($query_page) || !is_numeric($query_page)) {
if ($sitemap->getChunks() > 1) {
return 'index';
}
else {
return 1;
}
}
else {
return (int) $query_page;
}
}
/**
* Creates a response reading the sitemap file and adding content to response.
*
* @param \Symfony\Component\HttpFoundation\Response $response
* Response object.
* @param string $file
* File uri.
* @param array $headers
* Headers of the response.
*
* @return \Symfony\Component\HttpFoundation\BinaryFileResponse
* The sitemap response object.
*
* @throws \Symfony\Component\HttpKernel\Exception\NotFoundHttpException
* If the sitemap is not found or the sitemap file is not readable.
*
* @deprecated in xmlsitemap:8.x-1.0 and is removed from xmlsitemap:2.0.0. Use
* \Drupal\xmlsitemap\Controller\XmlSitemapController::getSitemapResponse()
* instead.
*
* @see https://www.drupal.org/project/xmlsitemap/issues/2869214
*/
function xmlsitemap_output_file(Response $response, $file, array $headers = []) {
@trigger_error(__FUNCTION__ . ' is deprecated in xmlsitemap:8.x-1.0 and will be removed in xmlsitemap:2.0.0. Use \Drupal\xmlsitemap\Controller\XmlSitemapController::getSitemapResponse. See https://www.drupal.org/project/xmlsitemap/issues/2869214', E_USER_DEPRECATED);
/** @var \Drupal\xmlsitemap\Controller\XmlSitemapController $controller */
$controller = \Drupal::classResolver(XmlSitemapController::class);
return $controller->getSitemapResponse($file, \Drupal::request(), $headers + $response->headers->all());
}
/**
* Get Blurb.
*
* Fetch a short blurb string about module maintainership and sponsors.
* This message will be FALSE in 'official' releases.
*
* @param mixed $check_version
* Check version.
*
* @static string $blurb
* Blurb message.
*
* @return string
* String with $blurb.
*/
function _xmlsitemap_get_blurb($check_version = TRUE) {
static $blurb;
if (!isset($blurb)) {
$blurb = FALSE;
if (!$check_version || (($version = _xmlsitemap_get_version()) && preg_match('/dev|unstable|alpha|beta|HEAD/i', $version))) {
$sponsors = [
\Drupal::linkGenerator()->generate('Symantec', Url::fromUri('http://www.symantec.com/', ['attributes' => ['target' => 'blank']])),
\Drupal::linkGenerator()->generate('WebWise Solutions', Url::fromUri('http://www.webwiseone.com/', ['attributes' => ['target' => 'blank']])),
\Drupal::linkGenerator()->generate('Volacci', Url::fromUri('http://www.volacci.com/', ['attributes' => ['target' => 'blank']])),
\Drupal::linkGenerator()->generate('lanetro', Url::fromUri('http://www.lanetro.com/', ['attributes' => ['target' => 'blank']])),
\Drupal::linkGenerator()->generate('Coupons Dealuxe', Url::fromUri('http://couponsdealuxe.com/', ['attributes' => ['target' => 'blank']])),
];
// Don't extract the following string for translation.
$blurb = '<div class="description"><p>Thank you for helping test the XML sitemap module rewrite. Please consider helping offset developer free time by <a href="http://davereid.chipin.com/" target="blank">donating</a> or if your company is interested in sponsoring the rewrite or a specific feature, please <a href="http://davereid.net/contact" target="blank">contact the developer</a>. Thank you to the following current sponsors: ' . implode(', ', $sponsors) . ', and all the individuals that have donated. This message will not be seen in the stable versions.</p></div>';
// http://drupalmodules.com/module/xml-sitemap
}
}
return $blurb;
}
/**
* Returns xmlsitemap module version.
*
* @static string $version
* Current version.
*
* @return string
* Xmlsitemap module version.
*/
function _xmlsitemap_get_version() {
static $version;
if (!isset($version)) {
$modules = \Drupal::service('extension.list.module')->getList();
$version = $modules['xmlsitemap']->info['version'];
}
return $version;
}
/**
* Check the status of all hook_requirements() from any xmlsitemap modules.
*
* @return bool
* TRUE if all requirements are met, FALSE otherwise.
*/
function xmlsitemap_check_status() {
$messages = &drupal_static(__FUNCTION__);
if (!isset($messages)) {
// Cache the list of modules that are checked.
if ($cache = \Drupal::cache()->get('xmlsitemap:registry:requirements')) {
$modules = $cache->data;
}
else {
$modules = [];
\Drupal::moduleHandler()->loadAllIncludes('install');
foreach (\Drupal::moduleHandler()->getImplementations('requirements') as $module) {
if (strpos($module, 'xmlsitemap') !== FALSE) {
$modules[] = $module;
}
}
\Drupal::cache()->set('xmlsitemap:registry:requirements', $modules, Cache::PERMANENT, ['xmlsitemap']);
}
$messages = [];
foreach ($modules as $module) {
module_load_install($module);
$requirements = \Drupal::moduleHandler()->invoke($module, 'requirements', ['runtime']);
foreach ($requirements as $requirement) {
if (isset($requirement['severity']) && max(REQUIREMENT_OK, $requirement['severity'])) {
$messages[] = $requirement['description'];
}
}
}
if ($messages) {
$messages = [
'#type' => 'item_list',
'#items' => [$messages],
];
$message = t('One or more problems were detected with your XML sitemap configuration: @messages', ['@messages' => \Drupal::service('renderer')->render($messages)]);
\Drupal::messenger()->addWarning($message, FALSE);
if (\Drupal::currentUser()->hasPermission('access site reports')) {
\Drupal::messenger()->addWarning(t('Check the <a href="@status-report">status report</a> for more information.', ['@status-report' => Url::fromRoute('system.status')->toString()]), FALSE);
}
}
}
return !empty($messages);
}
/**
* Perform operations before rebuilding the sitemap.
*/
function _xmlsitemap_regenerate_before() {
\Drupal::service('xmlsitemap_generator')->regenerateBefore();
}
/**
* Batch information callback for regenerating the sitemap files.
*
* @param array $smids
* An optional array of XML sitemap IDs. If not provided, it will load all
* existing XML sitemaps.
*/
function xmlsitemap_regenerate_batch(array $smids = []) {
if (empty($smids)) {
$sitemaps = \Drupal::entityTypeManager()->getStorage('xmlsitemap')->loadMultiple();
foreach ($sitemaps as $sitemap) {
$smids[] = $sitemap->id();
}
}
$t = 't';
$batch = [
'operations' => [],
'error_message' => $t('An error has occurred.'),
'finished' => 'xmlsitemap_regenerate_batch_finished',
'title' => t('Regenerating Sitemap'),
];
// Set the regenerate flag in case something fails during file generation.
$batch['operations'][] = ['xmlsitemap_batch_variable_set', [['xmlsitemap_regenerate_needed' => TRUE]]];
// @todo Get rid of this batch operation.
$batch['operations'][] = ['_xmlsitemap_regenerate_before', []];
// Generate all the sitemap pages for each context.
foreach ($smids as $smid) {
$batch['operations'][] = ['xmlsitemap_regenerate_batch_generate', [$smid]];
$batch['operations'][] = ['xmlsitemap_regenerate_batch_generate_index', [$smid]];
}
// Clear the regeneration flag.
$batch['operations'][] = ['xmlsitemap_batch_variable_set', [['xmlsitemap_regenerate_needed' => FALSE]]];
return $batch;
}
/**
* Batch callback; generate all pages of a sitemap.
*
* @param string $smid
* Sitemap entity id.
* @param array|\ArrayAccess $context
* Sitemap context.
*/
function xmlsitemap_regenerate_batch_generate($smid, &$context = []) {
\Drupal::service('xmlsitemap_generator')->regenerateBatchGenerate($smid, $context);
}
/**
* Batch callback; generate the index page of a sitemap.
*
* @param string $smid
* Sitemap entity id.
* @param array|\ArrayAccess $context
* Sitemap context.
*/
function xmlsitemap_regenerate_batch_generate_index($smid, &$context = []) {
\Drupal::service('xmlsitemap_generator')->regenerateBatchGenerateIndex($smid, $context);
}
/**
* Batch callback; sitemap regeneration finished.
*
* @param bool $success
* Checks if regeneration batch process was successful.
* @param array $results
* Results for the regeneration process.
* @param array $operations
* Operations performed.
* @param int $elapsed
* Time elapsed.
*/
function xmlsitemap_regenerate_batch_finished($success, array $results, array $operations, $elapsed) {
\Drupal::service('xmlsitemap_generator')->regenerateBatchFinished($success, $results, $operations, $elapsed);
}
/**
* Batch information callback for rebuilding the sitemap data.
*
* @param array $entity_type_ids
* Entity types to rebuild.
* @param bool $save_custom
* Save custom data.
*
* @return array
* Batch array.
*/
function xmlsitemap_rebuild_batch(array $entity_type_ids, $save_custom = FALSE) {
$batch = [
'operations' => [],
'finished' => 'xmlsitemap_rebuild_batch_finished',
'title' => t('Rebuilding Sitemap'),
'file' => drupal_get_path('module', 'xmlsitemap') . '/xmlsitemap.generate.inc',
];
// Set the rebuild flag in case something fails during the rebuild.
$batch['operations'][] = ['xmlsitemap_batch_variable_set', [['xmlsitemap_rebuild_needed' => TRUE]]];
// Purge any links first.
$batch['operations'][] = [
'xmlsitemap_rebuild_batch_clear', [$entity_type_ids, (bool) $save_custom],
];
// Fetch all the sitemap links and save them to the {xmlsitemap} table.
foreach ($entity_type_ids as $entity_type_id) {
$info = xmlsitemap_get_link_info($entity_type_id);
$batch['operations'][] = [$info['xmlsitemap']['rebuild callback'], [$entity_type_id]];
}
// Clear the rebuild flag.
$batch['operations'][] = ['xmlsitemap_batch_variable_set', [['xmlsitemap_rebuild_needed' => FALSE]]];
// Add the regeneration batch.
$regenerate_batch = xmlsitemap_regenerate_batch();
$batch['operations'] = array_merge($batch['operations'], $regenerate_batch['operations']);
return $batch;
}
/**
* Batch callback; set an array of variables and their values.
*
* @param array $variables
* Variables to be set during the batch process.
*/
function xmlsitemap_batch_variable_set(array $variables) {
\Drupal::service('xmlsitemap_generator')->batchVariableSet($variables);
}
/**
* Batch callback; clear sitemap links for entities.
*
* @param array $entity_type_ids
* Entity types to rebuild.
* @param bool $save_custom
* Save custom data.
* @param array|\ArrayAccess $context
* Context to be rebuilt.
*/
function xmlsitemap_rebuild_batch_clear(array $entity_type_ids, $save_custom, &$context = []) {
\Drupal::service('xmlsitemap_generator')->rebuildBatchClear($entity_type_ids, $save_custom, $context);
}
/**
* Batch callback; fetch and add the sitemap links for a specific entity type.
*
* @param string $entity_type_id
* Entity type ID.
* @param array|\ArrayAccess $context
* Sitemap context.
*/
function xmlsitemap_rebuild_batch_fetch($entity_type_id, &$context) {
\Drupal::service('xmlsitemap_generator')->rebuildBatchFetch($entity_type_id, $context);
}
/**
* Batch callback; sitemap rebuild finished.
*
* @param bool $success
* Checks if regeneration batch process was successful.
* @param array $results
* Results for the regeneration process.
* @param array $operations
* Operations performed.
* @param int $elapsed
* Time elapsed.
*/
function xmlsitemap_rebuild_batch_finished($success, array $results, array $operations, $elapsed) {
\Drupal::service('xmlsitemap_generator')->rebuildBatchFinished($success, $results, $operations, $elapsed);
}
/**
* Get all rebuildable entity types.
*
* @return array
* Array with all rebuildable entity types.
*/
function xmlsitemap_get_rebuildable_link_types() {
$rebuild_types = [];
$entities = xmlsitemap_get_link_info();
foreach ($entities as $entity => $info) {
if (empty($info['xmlsitemap']['rebuild callback'])) {
// If the entity is missing a rebuild callback, skip.
continue;
}
if (!empty($info['bundles']) && !xmlsitemap_get_link_type_enabled_bundles($entity)) {
// If the entity has bundles, but no enabled bundles, skip since
// rebuilding wouldn't get any links.
continue;
}
$rebuild_types[] = $entity;
}
return $rebuild_types;
}
/**
* Link bundle enable.
*
* Enable an entity bundle and create specific xmlsitemap settings config
* object.
*
* @param string $entity_type_id
* Entity type id.
* @param string $bundle_id
* Bundle id.
*
* @return bool
* Returns TRUE if operation was successful.
*/
function xmlsitemap_link_bundle_enable($entity_type_id, $bundle_id) {
if (\Drupal::config("xmlsitemap.settings.{$entity_type_id}.{$bundle_id}")->isNew()) {
$settings = [
'status' => XMLSITEMAP_STATUS_DEFAULT,
'priority' => XMLSITEMAP_PRIORITY_DEFAULT,
'changefreq' => 0,
];
xmlsitemap_link_bundle_settings_save($entity_type_id, $bundle_id, $settings);
}
return TRUE;
}
/**
* Link bundle check enabled.
*
* Check if a bundle is enabled and config object xmlsitemap.settings object
* exists.
*
* @param string $entity_type_id
* Entity type id.
* @param string $bundle_id
* Bundle id.
*
* @return bool
* Returns TRUE if bundle is enabled, FALSE otherwise.
*/
function xmlsitemap_link_bundle_check_enabled($entity_type_id, $bundle_id) {
return !\Drupal::config("xmlsitemap.settings.{$entity_type_id}.{$bundle_id}")->isNew();
}
/**
* Check if an entity is enabled and configuration exists for the entity type.
*
* @param string $entity_type_id
* Entity type id.
*
* @return bool
* Returns TRUE if bundle is enabled, FALSE otherwise.
*/
function xmlsitemap_link_entity_check_enabled($entity_type_id) {
$configuration = \Drupal::configFactory()->listAll("xmlsitemap.settings.{$entity_type_id}.");
return !empty($configuration);
}
/**
* Implements hook_xmlsitemap_link_alter() on behalf of metatag.module.
*/
function metatag_xmlsitemap_link_alter(array &$link, array $context) {
$enabled = &drupal_static(__FUNCTION__);
if (!isset($enabled)) {
$enabled = \Drupal::config('xmlsitemap.settings')->get('metatag_exclude_noindex');
}
if ($enabled && !empty($context['entity']) && $context['entity'] instanceof ContentEntityInterface && $link['access']) {
/** @var \Drupal\metatag\MetatagManagerInterface $metatagManager */
$metatagManager = \Drupal::service('metatag.manager');
$metatags = $metatagManager->tagsFromEntity($context['entity']);
if (!empty($metatags['robots']) && strpos($metatags['robots'], 'noindex') !== FALSE) {
$link['access'] = FALSE;
}
}
}