Add bulk enable "Generate automatic URL alias"/force option in bulk generate

Hi Weilinggu,
this feature is already implemented, you find it at the "Content" page (Drupal 7 as well as Drupal 8). You can read about it in the documentation (How does Pathauto determine if the 'Automatic URL alias' checkbox should be checked or not?) about Pathauto, here is an excerpt for the D7 version, but it applies also to D8, when you use the "Content" menu or admin/content as the url (url in the D7 documentation does not work in D8):

"If you have content you've created before installing Pathauto that you would like to ensure that the checkbox is checked whenever you edit them, then you should use the 'Update URL alias' bulk action on your content listing admin page (admin/content/node)."

Though there seems to be a problem, as it creates an URL alias for the checked content, but doesn't seem to update the cache like the individual URL-Alias update in the node edit would do. Workaround for the time being: command "drush cr" on the shell after the bulk creation, if you have drush installed or clear the cache on the admin/config/development/performance page.

Regards.

The OP already knows how to do this for nodes and wants to know how to do this for taxonomy terms.

The work around for assigning alias to existing content is to do bulk "Update URL-Alias" at /admin/content.

This is not entirely true by default because of pagination. If one has more than 50 items to update it will only update the first 50 items. I don't know if there is a workaround for this (in D7, the system proposed to perform the operation for the remaining items - with VBO module AFAIR).

So IMHO I would not consider that the feature is already implemented. I then agree with the request.

Thanks mstrelan and progzy, you are right. A force option would solve the problem for nodes and taxonomy terms. I now also think this feature request would be good to have in pathauto.

Huh, almost lost my comment, d.o just ignored it. Trying again...

There are two issues here.

The problem most if you are running into is a problem with the new pathauto state feature that's not working as intended yet. The idea is that it allows to *explicitly* opt out of aliases for certain entities and not have bulk generate or other re-saving re-generate it for them.

However, something there doesn't work correctly yet for entities that were created before there were pattern, it should still generate it from them. This behavior is actually a bug. And I think fixing that would solve the problem for most people.

Having a force option to even override those that explicitly opted out would be a feature on top of that, but I'm not sure that's really needed once the bug is resolved.

What would help to move this forward is writing tests. We have bulk generate tests, it should be possible to alter them to reproduce this behavior.

The code for this is in PathautoState.

Here is a patch with a test and another patch with the test and the fix.

Okay, now I see what is the logic that I removed doing. The test seems valid though. I will continue debugging.

Have you seen (and tried) https://github.com/md-systems/pathauto/issues/121#issuecomment-172396101 ?

Here's a patch that implements the force option, if it's decided that it's needed.

Copied from https://github.com/md-systems/pathauto/issues/121#issuecomment-172396101:

Yeah, that line is the root of the problem there. There are two things to think about:

I think if there is no state and no alias, then we should allow to create a new one (Which is different from having it explicitly set to FALSE). So that means the condition would be $path == $entity_path || $path == $pathauto_alias

I ported this feature from 7.x-1.x. The implementation is however completely different and hard to compare. Wondering if I introduced this in 8.x-1.x or if it's already in 7.x-1.x. There might be issues about it too there.

The second is the question if we should delete those that have no pathauto state or not. I think yes, Mass delete is IMHO something you very rarely use (you can just re-generate and it will respect that setting and update old aliases). Maybe clarify that in the documentation. Otherwise mass delete would become very slow as we'd have to load and check every entity.

Here is an alternative version based on what I learnt at #2655874: Improve error handling for "The given alias pattern always matches the route". Let's see what tests say.

Here is a new patch that includes the test from #2654990: Not possible to save custom alias when no pattern is configured, as it fixes that issue too.

1. +++ b/src/PathautoState.php
   @@ -39,34 +39,16 @@ class PathautoState extends TypedData {
   +        $entity = $this->parent->getEntity();
   +        $pattern = \Drupal::service('pathauto.generator')->getPatternByEntity($entity);
   +        $this->value = !empty($pattern) ? static::CREATE : static::SKIP;
   

   Yes, this might work, actually.

   So in case we don't have an explicit state, we do it based on whether we are able to create an alias or not, not whether we actually have one that matches.

   would be good to have an OK from @davereid on this.

2. +++ b/src/Tests/PathautoBulkUpdateTest.php
   @@ -80,7 +80,7 @@ class PathautoBulkUpdateTest extends WebTestBase {
        // This has generated 6 aliases. 5 nodes and one user that we created. There
        // is also UID 1 but that user was created before the path field existed,
        // so he does not have a pathauto state.
   -    $this->assertText('Generated 6 URL aliases.');
   

   comment needs to be updated. and it actually looks like that pretty much already provides test coverage.

Adjusted test comment as suggested. I have notified Dave Reid to chime in here.

We can still make adjustments, but this solves a ton of problems and goes in the right direction. Committed!

Using Drupal 8.1.6 and pathauto 8.1.0-alpha3.

I'm also using Content Translation with 2 languages.
This issue still persists.
"Generate bulk aliases" doesn't create aliases for any of my taxonomy terms.
Especially after "Delete aliases".

I need to edit each term and check "generate alias" one by one. :(

I ran into this problem today. I had programmatically created hundreds of nodes, but the 'Generate automatic URL alias' flag was not explicitly set which caused pathauto to use its own logic to determine whether or not to create a new path alias on update. This was fine on the initial creation because aliases were created as expected. However, if I changed something that required the alias to be rewritten, it would not rewrite because the new alias was different than the existing and the pathauto flag was not explicitly set.

So first I fixed my code for programmatic code generation adding this line...

$node->path['pathauto'] = TRUE;
node_save($node);

Next I had to deal with existing nodes that did not have the pathauto flag set. As this issue post says there is no way to do that. So I had to force the issue with a little bit of code.

function custom_module_node_presave($node) {
      $entity->path['pathauto'] = TRUE;
}

With this temporary function in place I ran the bulk update alias operations on my nodes... twice. The first time updated any aliases it could and also assigned pathauto=TRUE if not already set for all nodes. The second pass updated all the remaining aliases. When completed I removed the hook above.

It would be nice if pathauto offered a bulk operation to edit the pathauto flag on each node. However, until then you could use the above as I did. You could add conditions to the function above or simply use it as is and only run bulk update on all or a subset of the nodes that concern you.

I am using Drupal 7, but I didn't see a related issue in the 7 queue.

#24 worked for me. Thank you very much!

Hello,

I had a similar issue, with a Drupal 8.6 with lots of nodes without the pathauto check enabled, and I needed to re-generate all the aliases.

In order to enable this check in all the nodes:
Search in "key_value" table for the key "pathauto_state.node".
Then changed the value from i:0 to i:1 with a SQL Update.

In my case I needed to update all the nodes of all types, but in a specific case it can be filtered.

Maybe there is another way, but I didn't find it for bulk updates in order to enable this pathauto flag on nodes.

Thanks @SalvadorP it works perfectly for nodes.
But doesn't work for user, i did change pathauto_state.user to i:1 but it doesn't work.
There is any other way for users?

Hi @berramou,

I'm not sure about users, but maybe with this line on hook_entity_presave():

$entity->path->pathauto = PathautoState::CREATE;

I'm using this to set the pathauto on each node creation or update.

Using that in presave hook you may be able to set the pathauto for any entity.

Maybe you can find a bit more info or an idea in this issue https://www.drupal.org/project/pathauto/issues/2946273.

Hello @SalvadorP thank you for your replay.
I had another issue, Pathauto generate alias only for original language even if you don't select any language in the alias configuration.

With the config below, pathauto should generate the alias for all language e.g:
en/utilisateur/1
fr/utilisateur/1
es/utilisateur/1
ar/utilisateur/1

I had to bypass it with:

use Drupal\Core\Language\LanguageInterface;
/**
 * Implements hook_pathauto_pattern_alter().
 */
function MyModule_pathauto_pattern_alter(&$pattern, array $context) {
    if ($context['module'] == 'user') {
    $context['language'] = LanguageInterface::LANGCODE_NOT_SPECIFIED;
  } 
}

Now bulk operation generate alias for all languages.
I don't know is this normal behavior or it's an issue?

The problem

• When i created my content type, i forgot to make sure 'generate url alias automatically' was turned on. I created upwards of 50 nodes with the setting turned off.
• I created my alias pattern for the content type.
• I ran 'bulk generate' on my pattern, and the nodes did not generate updated aliases because 'generate url alias automatically' was not turned on for any of the newly created nodes.
• Use this code snippet ... place it in an appropriate module and run it. (If you're unable to do this please research setting up your own module):

$nids = Drupal::entityQuery('node')
    ->condition('type', 'CONTENT_TYPE')
    ->execute();
$nodes = Node::loadMultiple($nids);

foreach($nodes as $node) {
    $node->path->pathauto = 1;
    $node->save();
}

What does the code do?

• Loads all nodes of a specific content type.
• Loops through all the nodes and ...
• Turns the pathauto (automatically generate url alias) to 1 (ie: on, ie: checked).
• Saves the node and generates the alias.

I understand why there is no option to turn on 'automatically generate url alias' for all nodes of a certain type, because what if you only want a certain batch of them based on some condition to have the option turned on.

The solution above was a quick way to turn on 'generate automatic url alias' for ALL nodes in a content type.

Thanks to SalvadorP for comment #26 which was (for me) the easiest to setup (commerce_product entity).

Pathauto in Drupal 8/9 has an "Update URL Alias" action that can be used from the /admin/content page to bulk update all nodes, or nodes of a given content type, to use their configured pathauto pattern.

Tested this for nodes that had not gotten their aliases from a bulk generate and it worked.

Practically speaking if you want to do more than 50 nodes at a time you'll want https://www.drupal.org/project/views_bulk_operations

Tried to make a module and it didn't work out but here's a MySQL/MariaDB query to do this for people:

UPDATE node AS n INNER JOIN key_value AS kv ON n.nid=kv.name LEFT JOIN path_alias AS pa ON CONCAT('/node/', n.nid)=pa.path SET kv.value='i:1;' WHERE kv.collection='pathauto_state.node' AND kv.value='i:0;' AND pa.alias IS NULL;

Came across this nightmare left over from Drupal versions of yesteryears and i see still can't properly force url aliases being set.

- none of the bulk generate options work
- Using VBO and views bulk edit, it allows setting the "Generate URL Alias" checkbox - but doesn't work
- there is no Update URL Alias action available (to VBO)

but then came across this post and it reminded me that in D8/9 we have 2 types of actions (so annoying) VBO compatible ones and Core ones. Sure enough the action is there in a core bulk update view and it does work.. yay.. Of course, as just mentioned above.. only good if you want to do a page at a time.

Pretty sure this should not be marked as fixed as there is no proper solution for this.

Just noting I also just caught up on this, and still find the current system of config and options convoluted and confusing.

1. Create a site
2. Create some content
3. Enable pathauto
4. No option to easily resolve unchecked "Automatically generate URL alias" content

• Need an option to enable/disable the checkbox for all nodes of a content type/taxonomy/user

In Drupal Commerce site, if you happen to add Pathauto to products a bit late and want to check "Generate URL Alias" for all the products place this code in any theme hook function and reload website ONCE, then remove the code and you are good to go.

$ids = Drupal::entityQuery('commerce_product')
	->execute();

$products = \Drupal::entityTypeManager()->getStorage('commerce_product')->loadMultiple($ids);

foreach($products as $product) {
	$product->path->pathauto = 1;
	$product->save();
}

I think this could be easily made to a contrib module or maybe just a snipplet in documentation would work.

@lubwn you could use an update hook instead that let's you do bulk updates without timing out if you have many entities and you can also leave the code because it will only execute once on each environment.

function mymodule_update_9001(&$sandbox) {
  // Initialize variables on the first run.
  if (!isset($sandbox['total'])) {
    $entity_list = \Drupal::entityQuery('node')
      ->condition('type', 'my_entity')
      ->execute();
    $langcodes = \Drupal::languageManager()->getLanguages();
    $sandbox['langcodes'] = array_keys($langcodes);
    $sandbox['total'] = count($entity_list);
    $sandbox['current'] = 0;
  }

  // Batch cycle.
  $batch_nids = \Drupal::entityQuery('node')
    ->condition('type', 'my_entity')
    ->range($sandbox['current'], 15)
    ->execute();

  foreach ($batch_nids as $nid) {
    $my_entity = \Drupal::entityTypeManager()->getStorage('node')->load($nid);
    // Loop through all languages.
    foreach ($sandbox['langcodes'] as $langcode) {
      if ($my_entity->hasTranslation($langcode)) {
        $my_entity_translation = $my_entity->getTranslation($langcode);
        // Avoid re-saving nodes that don't need to be updated.
        if ($my_entity_translation->path->pathauto !== 1) {
          $my_entity_translation->path->pathauto = 1;
          $my_entity_translation->save();
        }
      }
    }
    $sandbox['current']++;
  }


  if ($sandbox['current'] >= $sandbox['total']) {
    $sandbox['#finished'] = 1;
    \Drupal::messenger()->addMessage('A total of ' . $sandbox['total'] . ' entities were updated.');

  }
  else {
    $sandbox['#finished'] = ($sandbox['current'] / $sandbox['total']);
    // Output a message to inform about the ongoing process.
    \Drupal::messenger()->addMessage($sandbox['current'] . ' entities were updated out of ' . $sandbox['total']);
  }
}

Using Drupal 10.4, and running the "Update URL Alias" action does not enable the "Generate automatic URL alias" setting on the nodes, so I also don't see that this is a closed task..?

I did this for a one off, test locally and use at own risk!

drush php-eval "use Drupal\node\Entity\Node; 
\$nodes = \Drupal::entityTypeManager()->getStorage('node')->loadByProperties(['type' => 'my_node_bundle']);
foreach (\$nodes as \$node) {
  if (\$node->hasField('path')) {
    \$node->path->pathauto = 1;
    \$node->save();
  }
}"

Following up vegardjo's suggestion, another code snippet that does not trigger a node save:

    $connection = \Drupal::database();
    $bundles = [
      'my_node_bundle',
      'my_other_node_bundle',
    ];
    $nodes = \Drupal::entityQuery('node')
      ->condition('type', $bundles, 'IN')
      ->accessCheck(FALSE)
      ->execute();
    foreach ($nodes as $nid) {
      $connection->merge('key_value')
        ->keys([
          'collection' => "pathauto_state.node",
          'name' => $nid,
        ])
        ->fields([
          'value' => serialize(1),
        ])
        ->execute();
    }

This only updates the key_value table, which immitates the class PathautoState 's logic.

And here too: use at own risk!