Has anyone managed to alias taxonomy_menu?

I would like to find a way to do that too.

The feature seems to be lost somewhere in between pathauto and taxonomy_menu maintainers...

It could be (must say hardly it was:)) implemeted using custom_url_rewrite: you must change taxonomy/term/id links to their taxonomy_menu hierarchical equialents.

<warning>There could be all sorts of problems with other modules if you implement this change. I am using only pathauto and taxonomy_menu. If you try this change and a demonic force takes away your Web site or your first born child or makes your ipod play Neil Diamond songs, that is your penance for experimenting with raw code.</warning>

Pathauto uses path_set_alias() and path_set_alias() contains the following code:

elseif($path_count == 1 && $alias_count == 1)
	{
	// This will delete the path that alias was originally pointing to:
	path_set_alias(NULL, $alias);
	path_set_alias($path);
	path_set_alias($path, $alias);
	}

pathauto creates one alias and taxonomy menu creates another. When you update a page you can end up with the pathauto alias returning a path count of 1 and the taxonomy_menu alias returning an alias count of 1. The code then deletes both entries before creating the new one, which is usually the pathauto entry.

To fix this problem you could change the url_alias table to contain the name of the module that creates an alias and limit modules to maintaining their own aliases.

Another fix would be to use the pid (path id) if supplied. Change the path_set_alias() code to process the pid before the other stuff. Pathauto supplies a pid when it wants to update pids. If the pid is supplied and the pid exists then update the pid.

I changed the start of path_set_alias() from:

function path_set_alias($path = NULL, $alias = NULL, $pid = NULL)
	{
	if ($path && !$alias)

to:

function path_set_alias($path = NULL, $alias = NULL, $pid = NULL)
	{
	if ($pid)
		{
		db_query("UPDATE {url_alias} SET dst = '%s', src = '%s' WHERE pid = %d", $alias, $path, $pid);
		drupal_clear_path_cache();
		return;
		}
	if ($path && !$alias)

That removed one incompatibility between pathauto and taxonomy_menu because pathauto no longer deletes taxonomy_menu entries when updating pathauth entries.

There is still a problem where pathauto will not create the right path for a new page. I get around it by creating the page then immediately updating it. For page x/y/z, pathauto creates path x/y/z_0 and I immediately update the URL to remove the _0.

petermoulding.com/web_architect

Test the following code as a pathauto API version of taxonomy_menu. Try placing the following in a file named pathauto_taxonomy_menu.inc within the modules/pathauto directory. You can then remove the path alias build out of taxonomy_menu and test the result. The second chunck of code is the replacement taxonomy_menu_menu() for taxonomy_menu.module.

Do not try this on any Web site that controls nuclear submarines or is connected to the Internet or is useful or is anything else.

pathauto_taxonomy_menu.inc

/* Copyright PeterMoulding.com 2006
Free for use in Drupal.
*/

/*
 * Implementation of hook_pathauto()
 */

function taxonomy_menu_pathauto($op)
	{
	switch ($op)
		{
		case 'settings':
			return taxonomy_menu_pathauto_settings();
		default:
			break;
		}
	}

function taxonomy_menu_pathauto_settings()
	{
	/* Copyright PeterMoulding.com 2006 04 07
	2/ Add use of variable taxonomy_menu_display_vocabulary.
	*/
	$use_vocabulary_name = false;
	if(variable_get('taxonomy_menu_display_vocabulary', 1))
		{
		$use_vocabulary_name = true;
		}
	
	$settings = array();
	$settings['module'] = 'taxonomy_menu';
	$settings['groupheader'] = t('Category menu path settings');
	$settings['patterndescr'] = t('Default menu path pattern (applies to all vocabularies with blank patterns below)');
	$settings['patterndefault'] = t('[vocab]/[catpath]');
	if($use_vocabulary_name)
		{
		$settings['patterndefault'] = t('[catpath]');
		}
	$settings['placeholders'] = array(
		t('[vocab]') => t("The vocabulary that the page's first category belongs to."),
		t('[cat]') => t('The name of the category.'),
		t('[catpath]') => t('As [cat], but including its supercategories.'),
		t('[tid]') => t('The id number of the category.')
		);
	// Look for extensions from other modules
	$placeholders = module_invoke_all('pathauto_taxonomy_menu', 'placeholders');
	$settings['placeholders'] = array_merge($settings['placeholders'], $placeholders);
	
	$settings['bulkname'] = t('Bulk update category menu paths');
	$settings['bulkdescr'] = 
	t('Generate menu aliases for all existing categories which do not already have aliases.');
	
	$vocabularies = taxonomy_get_vocabularies();
	if (sizeof($vocabularies) > 0)
		{
		$settings['patternitems'] = array();  
		foreach ($vocabularies as $vocabulary)
			{
			$vocabulary_name = $vocabulary->name;
			$fieldlabel = t('Pattern for all ' . $vocabulary_name . ' menu paths');
			$settings['patternitems'][$vocabulary->vid] = $fieldlabel;
			}
		}
	return (object) $settings;
	}

/**
 * Implementation of hook_taxonomy().
 */
function pathauto_taxonomy_menu($op, $type, $object = NULL)
	{
	switch ($type)
		{
		case 'term':
			pathauto_taxonomy_menu_term($op, $object);
			break;
		default:
			break;
		}
	}
function pathauto_taxonomy_menu_term($op, $object = NULL)
	{
	switch ($op)
		{
		case 'insert':
		case 'update':
			pathauto_taxonomy_menu_term_insert($op, $object);
			break;
		case 'delete':
			pathauto_taxonomy_menu_term_delete($object);
			break;
		default:
			break;
		}
	}
function pathauto_taxonomy_menu_term_delete($object = NULL)
	{
	/*
	** If the category is deleted, remove the path aliases
	**
	*/
	$category = (object) $object;
	path_set_alias('taxonomy_menu/' . $category->tid);
	}
function pathauto_taxonomy_menu_term_insert($op, $object = NULL)
	{
	//case 'insert':
	//case 'update':
	/*
	** Use the category info to automatically create an alias
	*/
	$category = (object) $object;
	if ($category->name)
		{
		$placeholders = array();
		
		$vid = $category->vid;
		$vocabulary = taxonomy_get_vocabulary($vid);
		$placeholders[t('[vocab]')] = pathauto_cleanstring($vocabulary->name);
		
		$placeholders[t('[cat]')] = pathauto_cleanstring($category->name);
		$placeholders[t('[tid]')] = $category->tid;
		
		if ($category->parent)
			{
			$catpath = pathauto_cleanstring($category->name);
			$parents = taxonomy_get_parents_all($category->parent);
			}
		else
			{
			$catpath = '';
			$parents = taxonomy_get_parents_all($category->tid);
			}
		
		foreach ($parents as $parent)
			{
			$catpath = pathauto_cleanstring($parent->name) . '/' . $catpath;
			}
		$placeholders[t('[catpath]')] = $catpath;
		
		// Append any additional extensions
		$extplaceholders = module_invoke_all('pathauto_taxonomy-menu', 'values', $category);
		$placeholders = array_merge($placeholders, $extplaceholders);
		
		$src = 'taxonomy_menu/' . $category->tid;
		$alias = pathauto_create_alias('taxonomy_menu', $op, $placeholders, $src, $vid);
		}
	}

// Generate menu aliases for all categories without aliases
function taxonomy_menu_pathauto_bulkupdate()
	{
	$query = 'select tid, vid, name, src, dst from {term_data} '.
		"left join {url_alias} on concat('taxonomy_menu/', tid) = src";
	$result = db_query($query);
	$count = 0;
	while($category = db_fetch_object($result))
		{
		$vid = $category->vid;
		$vocabulary = taxonomy_get_vocabulary($vid);
		$placeholders = array();
		$placeholders[t('[vocab]')] = pathauto_cleanstring($vocabulary->name);
		$placeholders[t('[cat]')] = pathauto_cleanstring($category->name);
		$placeholders[t('[tid]')] = $category->tid;
		$src_list = array();
		
		if ($category->parent)
			{
			$catpath = pathauto_cleanstring($category->name);
			$parents = taxonomy_get_parents_all($category->parent);
			}
		else
			{
			$catpath = '';
			$parents = taxonomy_get_parents_all($category->tid);
			}
		
		foreach ($parents as $parent)
			{
			$catpath = pathauto_cleanstring($parent->name) . '/' . $catpath;
			array_unshift($src_list, $parent->tid);
			}
		$placeholders['[catpath]'] = $catpath;
		
		array_unshift($src_list, $vid);
		$src = 'taxonomy_menu/' . implode('/', $src_list);
		if ($alias = pathauto_create_alias('taxonomy_menu', 'bulkupdate',
			$placeholders, $src, $vid))
			{
			$count++;
			}
		}
	
	drupal_set_message(format_plural($count,
		'Bulk update of terms completed, one menu alias generated.',
		'Bulk update of terms completed, %count menu aliases generated.'));
	}

taxonomy_menu.module

Replace taxonomy_menu_menu().

/* Copyright PeterMoulding.com 2005 09 09
1/ Fix formatting.
2/ Add use of variable taxonomy_menu_display_vocabulary.
*/
function taxonomy_menu_menu($may_cache)
	{
	$items = array();
	if ($may_cache)
		{
		$access = user_access('access content');
		
		/* Copyright PeterMoulding.com 2006 04 07
		2/ Add use of variable taxonomy_menu_display_vocabulary.
		*/
		$use_vocabulary_name = false;
		if(variable_get('taxonomy_menu_display_vocabulary', 1))
			{
			$use_vocabulary_name = true;
			}
		
		foreach (taxonomy_get_vocabularies() as $vocabulary)
			{
			if (variable_get('taxonomy_menu_show_'. $vocabulary->vid, 1))
				{
				$path = 'taxonomy_menu/'. $vocabulary->vid;
				/* Copyright PeterMoulding.com 2006 04 07
				2/ Add use of variable taxonomy_menu_display_vocabulary.
				$items[] = array('path' => $path, 'title' => t($vocabulary->name),
					'callback' => 'taxonomy_menu_page', 'access' => $access,
					'weight' => $vocabulary->weight);
				*/
				if($use_vocabulary_name)
					{
					$items[] = array('path' => $path, 'title' => t($vocabulary->name),
						'callback' => 'taxonomy_menu_page', 'access' => $access,
						'weight' => $vocabulary->weight);
					}
				
				$tree = taxonomy_get_tree($vocabulary->vid);
				$old_depth = -1;
				$old_path = $path;
				foreach ($tree as $term)
					{
					if ($term->depth <= $old_depth)
						{
						$slashes_to_remove = $old_depth - $term->depth + 1;
						for ($i = 0; $i < $slashes_to_remove; $i++)
							{
							$old_path = substr($old_path, 0, strrpos($old_path, '/'));
							}
						}
					
					$path = $old_path .'/'. $term->tid;
					$old_depth = $term->depth;
					$old_path = $path;
					
					/* Copyright PeterMoulding.com 2005 09 09
					2/ Add use of variable taxonomy_menu_display_vocabulary.
					$items[] = array('path' => $path, 'title' => t($term->name),
					'weight' => $term->weight);
					*/
					if($use_vocabulary_name or $term->depth > 0)
						{
						$items[] = array('path' => $path, 'title' => t($term->name),
							'weight' => $term->weight);
						}
					else
						{
						$items[] = array('path' => $path, 'title' => t($term->name),
							'callback' => 'taxonomy_menu_page',
							'access' => $access,
							'weight' => $term->weight);
						}
					}
				}
			}
		}
	return $items;
	}

petermoulding.com/web_architect

See Allow manual specification of parent. It is the start of a change to make taxonomy menu work using the aliases from taxonomy+pathauto, the paths of the form taxonomy/term/99. I have the change working on a test system and will put it in a production system next week.

If you feel comfortable modifying includes/menu.inc then let me know and I will post the related changes for taxonomy_menu.

petermoulding.com/web_architect

I have made changes to the includes/menu.inc. Can you post the changes for taxonomy_menu. thanks

Subscribe.

after trying out various modules/approaches (http://drupal.org/node/170752) I temporarily gave up the idea of having a dynamically updated menu trees generated by my toxonomies - at least for this one project I'm currently working on.. Instead I'll have 'hand-made' taxo-menues..

Anyways - the problem remains the same..

I tried to start a discussion on "what's your dynamic menu approach" over here: http://drupal.org/node/171535
and I tried to write down my experiences and wishes over here: http://drupal.org/node/170752
..but both with very little response.
Instead I received a notification about a new module tax'o'menu: http://drupal.org/project/taxomenu
..but I actually haven't found the time to digg into it - yet.

Has anybody tried it out..? ..or even other/better experiences..?

greetz, t..

___________________________
my pictures: www.bilderbook.org

subscribing

Apparently, I overlooked the efforts of another user and have my own version of taxonomy_menu with pathauto support. The code below is a complete replacement for taxonomy_menu.module. This module will create the appropriate URL aliases for the taxonomy_menu/* URLs as well as appropriate aliases for taxonony/term/*/feed. Unfortunately, there may be some overlap in feed aliases should you choose to create aliases for taxonomy terms as well. Given the fact that I have only known of Drupal for less than a week now, please use the following code with caution and be sure to backup your URL aliases.

<?php
// $Id: taxonomy_menu.module,v 1.4 2007/10/01 23:00:01 sinis Exp $

/**
 * Implementation of hook_help().
 */
 function taxonomy_menu_help($section) {
     switch ($section) {
         case 'admin/help#taxonomy_menu':
             $output = '<p>'. t('Taxonomy terms allow classification of content into categories and subcategories.  The taxonomy menu module adds links to the navigation menu for taxonomy terms.  This is useful when the community is focused on creating content that is organized in a taxonomy.') .'</p>';
             $output .= '<p>'. t('The taxonomy menu administration interface allows taxonomy terms to be enabled to show in the navigation menu.  You can also select whether a term\'s descendents subterms are displayed.') .'</p>';
             $output .= t('<p>You can</p>
<ul>
<li>view a list of taxonomies in <a href="@admin-taxonomy">Administer &gt;&gt; Content management &gt;&gt; Categories</a>.</li>
<li>create a new vocabulary at <a href="@admin-taxonomy-add-vocabulary">Administer &gt;&gt; Content management &gt;&gt; Categories &gt;&gt; Add vocabulary</a>.</li>
</ul>', array('@admin-taxonomy' => url('admin/content/taxonomy'), '@admin-taxonomy-add-vocabulary' => url('admin/content/taxonomy/add/vocabulary')));
             $output .= '<p>'. t('For more information please read the configuration and customization handbook <a href="@taxonomy_menu">Taxonomy menu page</a>.', array('@taxonomy_menu' => 'http://www.drupal.org/handbook/modules/taxonomy_menu/')) .'</p>';
             return $output;
     }
 }

 /**
  * Implementation of hook_menu().
  *
  * Most of the heavy lifting of the module is done here.
  */
  function taxonomy_menu_menu($may_cache) {
      $items = array();

      if ($may_cache) {
          $items[]= array (
          'path' => 'admin/settings/taxonomy_menu',
          'title' => t('Taxonomy Menu settings'),
          'callback' => 'drupal_get_form',
          'callback arguments' => array('taxonomy_menu_admin_settings'),
          'access' => user_access('administer site configuration'),
          'description' => t('Global configuration of taxonomy menu functionality.'),
          'type' => MENU_NORMAL_ITEM,
          );

          $access = user_access('access content');

          foreach (taxonomy_get_vocabularies() as $vocabulary) {
              if (variable_get('taxonomy_menu_show_'. $vocabulary->vid, 1)) {
                  $path = 'taxonomy_menu/'. $vocabulary->vid;
                  $items[] = array(
                  'path' => $path,
                  'title' => t($vocabulary->name),
                  'callback' => 'taxonomy_menu_page',
                  'access' => $access,
                  'weight' => $vocabulary->weight
                  );

                  $tree = taxonomy_get_tree($vocabulary->vid);
                  $old_depth = -1;
                  $old_path = $path;

                  foreach ($tree as $term) {
                      if ($term->depth <= $old_depth) {
                          $slashes_to_remove = $old_depth - $term->depth + 1;
                          for ($i = 0; $i < $slashes_to_remove; $i++) {
                              $old_path = substr($old_path, 0, strrpos($old_path, '/'));
                          }
                      }
                      $path = $old_path .'/'. $term->tid;
                      $old_depth = $term->depth;
                      $old_path = $path;
                      $items[] = array(
                      'path' => $path,
                      'title' => t($term->name),
                      'weight' => $term->weight
                      );
                  }
              }
          }
      }

      return $items;
  }

  /**
   * Implementation of hook_taxonomy().
   *
   * Invalidates the menu cache on taxonomy changes.
   */
   function taxonomy_menu_taxonomy($op, $type, $object = NULL) {
       if(module_exists('pathauto')) {
           _pathauto_include();

           switch ($type) {
               case 'term':
                   $category = (object) $object;
                   $vocabulary = taxonomy_get_vocabulary($category->vid);

                   $parents = taxonomy_get_parents_all($category->tid);
                   $path = $category->tid;
                   foreach ($parents as $parent) {
                       if( $category->tid != $parent->tid) { // Skip ourselves
                           // Replace any / characters in individual terms which might create confusing URLs
                           $separator = variable_get('pathauto_separator', '-');
                           $path = $parent->tid .'/'. $path;
                       }
                   }
                   $path = 'taxonomy_menu/' . $vocabulary->vid . '/' . $path;

                   switch ($op) {
                       case 'insert':
                       case 'update':
                           $placeholders = pathauto_get_placeholders('taxonomy_menu', $category);

                           /*
                            ** Use the category info to automatically create an alias
                            */

                            if ($category->name) {
                                $alias = pathauto_create_alias('taxonomy_menu', 'update', $placeholders, $path, null);

                                # Fixup to point the feeds at the taxonomy module rather than here
                                if( variable_get('pathauto_taxonomy_menu_supportsfeeds', '') ) {
                                    $feed = (variable_get('taxonomy_menu_display_descendants', 1) ? 'all' : 0) .'/feed';
                                    path_set_alias('taxonomy/term/' . $term->tid . '/' . $feed, $alias . '/' . $feed);
                                }

                            }
                            break;
                       case 'delete':
                           $feed = (variable_get('taxonomy_menu_display_descendants', 1) ? 'all' : 0) .'/feed';
                           //If the category is deleted, remove the path aliases
                           path_set_alias($path);
                           path_set_alias($path . $feed);
                           break;
                       default:
                           break;
                   }
                   break;

                       case 'vocabulary':
                           $vid = $object['vid'];
                           $name = $object['name'];
                           switch ($op) {
                               case 'insert':
                               case 'update':
                                   $path = 'taxonomy_menu/' . $vid;
                                   $placeholders = array(
                                   'tokens' => array(
                                   '[taxonomy_menu_catpath]',
                                   '[taxonomy_menu_catalias]',
                                   '[taxonomy_menu_vocab]',
                                   '[taxonomy_menu_cat]',
                                   ), 'values' => array(
                                   '',
                                   '',
                                   $name,
                                   '',
                                   ),
                                   );
                                   pathauto_create_alias('taxonomy_menu', 'update', $placeholders, $path, null);
                                   break;
                               case 'delete':
                                   $feed = (variable_get('taxonomy_menu_display_descendants', 1) ? 'all' : 0) .'/feed';
                                   // First, we must recursively delete aliases for terms
                                   $tree = taxonomy_get_tree($vid);
                                   $old_depth = -1;
                                   $old_path = 'taxonomy_menu/' . $vid;

                                   foreach ($tree as $term) {
                                       if ($term->depth <= $old_depth) {
                                           $slashes_to_remove = $old_depth - $term->depth + 1;
                                           for ($i = 0; $i < $slashes_to_remove; $i++) {
                                               $old_path = substr($old_path, 0, strrpos($old_path, "/"));
                                           }
                                       }
                                       $path = $old_path .'/'. $term->tid;
                                       $old_depth = $term->depth;
                                       $old_path = $path;
                                       
                                       path_set_alias($path);
                                       path_set_alias($path . $feed);
                                   }

                                   // Now remove the vocabulary aliases
                                   path_set_alias('taxonomy_menu/'. $vid);
                                   path_set_alias('taxonomy_menu/'. $vid . $feed);
                                   break;
                               default:
                                   break;
                           }
                               default:
                                   break;
           }
       }

       menu_rebuild();
   }

   /**
    * Menu callback; manage settings for taxonomy menu.
    */
    function taxonomy_menu_admin_settings() {
        $form['taxonomy_menu_display_descendants'] = array(
        '#type' => 'checkbox',
        '#title' => t('Display descendants'),
        '#return_value' => 1,
        '#default_value' => variable_get('taxonomy_menu_display_descendants', 1),
        '#description' => t('If checked, then when a term is selected all nodes belonging to subterms are also displayed.'),
        );
         
        foreach (taxonomy_get_vocabularies() as $vocabulary) {
            $form['taxonomy_menu_show_' . $vocabulary->vid] = array(
            '#type' => 'checkbox',
            '#title' => t('Show "%vocab" in menu', array('%vocab' => t($vocabulary->name))),
            '#return_value' => 1,
            '#default_value' => variable_get('taxonomy_menu_show_' . $vocabulary->vid, 1),
            );
        }

        return system_settings_form($form);
    }

    /**
     * Page callback that renders a node listing for the selected term.
     */
     function taxonomy_menu_page() {
         if (arg(2)) {
             $arguments = explode('/', $_GET['q']);
             $main_tid = db_escape_string(array_pop($arguments));

             $feed = url('taxonomy/term/'. $main_tid .'/'. (variable_get('taxonomy_menu_display_descendants', 1) ? 'all' : 0) .'/feed');
             drupal_add_feed($feed);

             $result = taxonomy_select_nodes(array($main_tid), 'or', variable_get('taxonomy_menu_display_descendants', 1) ? 'all' : 0);
         }
         else {
             // If no arg(2), we're looking at just the vid. If display_descendants
             // is on, grab all terms regardless of depth. If off, grab depth 0 terms.
             $tree = taxonomy_get_tree(arg(1));
             $descendants = variable_get('taxonomy_menu_display_descendants', 1);
             foreach ($tree as $term) {
                 if ($descendants || $term->depth == 0) {
                     $tids[] = $term->tid;
                 }
             }

             // The requested terms have already been determined, so don't request
             // descendants here.
             $result = taxonomy_select_nodes($tids, 'or', 0);
         }


         return taxonomy_render_nodes($result);
     }

     /**
      * Implementation of hook_nodeapi().
      *
      * This hook enables the menu to be displayed in context during node views.
      */
      function taxonomy_menu_nodeapi(&$node, $op, $a3, $a4) {
          switch ($op) {
              case 'view':
                  if ($a4 == TRUE) {
                      // The node is being displayed on its own page.
                      foreach (taxonomy_get_vocabularies() as $vocabulary) {
                          if (variable_get('taxonomy_menu_show_'. $vocabulary->vid, 1)) {
                              $path = 'taxonomy_menu/' . $vocabulary->vid;

                              $tree = taxonomy_get_tree($vocabulary->vid);
                              $old_depth = -1;
                              $old_path = $path;

                              foreach ($tree as $term) {
                                  if ($term->depth <= $old_depth) {
                                      $slashes_to_remove = $old_depth - $term->depth + 1;
                                      for ($i = 0; $i < $slashes_to_remove; $i++) {
                                          $old_path = substr($old_path, 0, strrpos($old_path, "/"));
                                      }
                                  }
                                  $path = $old_path .'/'. $term->tid;
                                  $old_depth = $term->depth;
                                  $old_path = $path;
                                  if (in_array($term->tid, array_keys(taxonomy_node_get_terms($node->nid)))) {
                                      menu_set_location(array(array('path' => $path, 'title' => t($term->name)), array('path' => 'node/'. $node->nid, 'title' => $node->title)));
                                      // Quit after the first match.
                                      return;
                                  }
                              }
                          }
                      }
                  }
                  break;
          }
      }

      /**
       * Implementation of hook_token_values() for Pathauto specific tokens
       */
       function taxonomy_menu_token_values($type, $category = NULL) {

           if($type == 'taxonomy_menu') {
               $parents = taxonomy_get_parents_all($category->tid);
               $menupath = $category->tid;
               foreach ($parents as $parent) {
                   // Replace any / characters in individual terms which might create confusing URLs
                   $separator = variable_get('pathauto_separator', '-');
                   $catpath = preg_replace('/\//', '', $parent->name) .'/'. $catpath;
                   $menupath = $category->tid . '/' . $menupath;
               }
               $values['taxonomy_menu_catpath'] = $catpath;
               $menupath = $category->vid . '/' . $menupath;

               $vocabulary = taxonomy_get_vocabulary($category->vid);
               $values['taxonomy_menu_vocab'] = $vocabulary->name;

               $values['taxonomy_menu_cat'] = $category->name;

               $values['taxonomy_menu_catalias'] = drupal_get_path_alias('taxonomy_menu/' . $menupath);
               if (!strncasecmp($values['taxonomy_menu_catalias'], 'taxonomy_menu', 13)) {
                   $values['taxonomy_menu_catalias'] = $values['taxonomy_menu_cat'];
               }
           }

           return $values;
       }

       /**
        * Implementation of hook_token_list() for Pathauto specific tokens
        */
        function taxonomy_menu_token_list($type = 'all') {
            if ($type == 'taxonomy_menu' || $type == 'all') {
                $tokens['taxonomy_menu']['taxonomy_menu_catpath'] = t("This category including its supercategories separated by /.");
                $tokens['taxonomy_menu']['taxonomy_menu_catalias'] = t("URL alias for the category.");
                $tokens['taxonomy_menu']['taxonomy_menu_vocab'] = t('The first vocabulary name returned for this category.');
                $tokens['taxonomy_menu']['taxonomy_menu_cat'] = t('The current category.');
            }

            return $tokens;
        }

        /*
         * Implementation of hook_pathauto()
         */

         function taxonomy_menu_pathauto($op) {
             switch ($op) {
                 case 'settings':
                     $settings = array();
                     $settings['module'] = 'taxonomy_menu';
                     $settings['groupheader'] = t('Taxonomy menu path settings');
                     $settings['patterndescr'] = t('Default path pattern');
                     $settings['patterndefault'] = t('');
                     $patterns = token_get_list('taxonomy_menu');
                     $settings['placeholders'] = array();
                     foreach ($patterns as $type => $pattern_set) {
                         if ($type != 'global') {
                             foreach ($pattern_set as $pattern => $description) {
                                 $settings['placeholders'][t('['. $pattern .']')] = t($description);
                             }
                         }
                     }

                     $settings['supportsfeeds'] = (variable_get('taxonomy_menu_display_descendants', 1) ? 'all' : 0) .'/feed';
                     $settings['bulkname'] = t('Bulk generate aliases for categories that are not aliased');
                     $settings['bulkdescr'] = t('Generate aliases for all existing categories which do not already have aliases. Note: Bulk Update may not complete on large or slow sites. See the README.txt for more information.');

                     $vocabularies = taxonomy_get_vocabularies();
                     if (sizeof($vocabularies) > 0) {
                         $settings['patternitems'] = array();
                         foreach ($vocabularies as $vocab) {
                             $vocabname = $vocab->name;
                             $fieldlabel = t('Pattern for all %vocab-name paths', array('%vocab-name' => $vocabname));
                             $settings['patternitems'][$vocab->vid] = $fieldlabel;
                         }
                     }

                     return (object) $settings;
                 default:
                     break;
             }
         }

         /**
          * Generate aliases for all categories without aliases
          *
          */
          function taxonomy_menu_pathauto_bulkupdate() {
              $count = 0;

              foreach (taxonomy_get_vocabularies() as $vocabulary) {
                  if (variable_get('taxonomy_menu_show_'. $vocabulary->vid, 1)) {
                      $path = 'taxonomy_menu/' . $vocabulary->vid;
                      $placeholders = array(
                      'tokens' => array(
                      '[taxonomy_menu_catpath]',
                      '[taxonomy_menu_catalias]',
                      '[taxonomy_menu_vocab]',
                      '[taxonomy_menu_cat]',
                      ), 'values' => array(
                      '',
                      '',
                      $vocabulary->name,
                      '',
                      ),
                      );
                      pathauto_create_alias('taxonomy_menu', 'bulkupdate', $placeholders, $path, null);
                      $count++;

                      $tree = taxonomy_get_tree($vocabulary->vid);
                      $old_depth = -1;
                      $old_path = $path;

                      foreach ($tree as $term) {
                          if ($term->depth <= $old_depth) {
                              $slashes_to_remove = $old_depth - $term->depth + 1;
                              for ($i = 0; $i < $slashes_to_remove; $i++) {
                                  $old_path = substr($old_path, 0, strrpos($old_path, "/"));
                              }
                          }
                          $path = $old_path .'/'. $term->tid;
                          $old_depth = $term->depth;
                          $old_path = $path;
                          $placeholders = pathauto_get_placeholders('taxonomy_menu', $term);
                          $alias = pathauto_create_alias('taxonomy_menu', 'bulkupdate', $placeholders, $path, null);

                          # Fixup to point the feeds at the taxonomy module rather than here
                          if( variable_get('pathauto_taxonomy_menu_supportsfeeds', '') ) {
                              $feed = (variable_get('taxonomy_menu_display_descendants', 1) ? 'all' : 0) .'/feed';
                              path_set_alias('taxonomy/term/' . $term->tid . '/' . $feed, $alias . '/' . $feed);
                          }
                          $count++;
                      }
                  }
              }

              drupal_set_message(format_plural($count,
              "Bulk generation of terms completed, one alias generated.",
              "Bulk generation of terms completed, @count aliases generated.")
              );

          }

Subscribing

I am new (1 week) to drupal
I created a new site.
Just before inviting the search engines in, I want to solve the duplicate links created by the taxonomy menu.

The taxonomy menu produces links like
http://www.24hsoftware.com/taxonomy_menu/2/28
while the same category is at
http://www.24hsoftware.com/taxonomy/term/28

Here is a different idea:
How about putting the
/taxonomy_menu/*
in the robots.txt

search engines will not find it as duplicate content while other site links could give an entry point for the spiders in the categories.

What do you think?

Michael

~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
www.24Hsoftware.com

Ok I read all articles and spent some time thinking about this in the morning.

The problems seems coming from the fact that menu needs a proper url /taxonomy_menu/1/3 in order to use the function taxonomy_menu_page. That's fine.

But we all need also to use the alias with category/vocabulary_1/term_3 aliased to taxonomy/term/3.

bgoines78 rewrote part of the module recreating aliases with pathauto but what about leveraging work already done by pathauto simply checking if a path for a taxonomy term already exist?

Mi 2 eurocent suggestion is then to check if the alias exist then change the 'src' leaving all the rest. Just add the if line on menu definition as follows:

$path = $old_path .'/'. $term->tid;
if($alias = drupal_lookup_path('alias','taxonomy/term/' . $term->tid)) path_set_alias($path, $alias);
$old_depth = $term->depth;

Checked on my site and seems working. I didn't check for feed or everything else.

Hope this work.

ema

P.S.
Works for Drupal 5 - taxonomy_menu.module,v 1.17.2.1.2.1 2007/02/22

Un'altra Pavia e' possibile
www.kronstadt.it - www.mupa.it

Is this solved with the 5.x-1.0 release?

Better paths: instead creating paths based only on Terms IDs, it uses also the Terms Names

Thanks

One of the things I dislike about taxonomy_menu is having to manually redo the URL, why can't this be automated based on the vocab and terms, url category/2 makes absolutely no sense, neither does category/vocab/term
we shouldn't have to manually edit every content

ie if the vocab is blog and the term is apples then the url should naturally be domain/blog/apples

Based on the module "Rewrite" by levavie I put the following code at the end of my settings.php:

 if(!function_exists("custom_url_rewrite")){
	function custom_url_rewrite($type, $alias, $real_path) {
	  $path = ( $alias ) ? $alias : $real_path;
	  $parts = explode('/', $path);
	  if ($parts[0] == variable_get('taxonomy_menu_display_page', 'taxonomy_menu')) {
	    $path = 'taxonomy/term/'. end($parts);

	    $result = db_query( "SELECT dst FROM {url_alias} WHERE src= '%s'", $path);
	    while ($row = db_fetch_object($result)) {
	      $path = $row->dst;
	      break;
	    }

	  }
	  return $path;
	}
}

Now it works fine with pathauto generated paths.

---------------------------------------------
www.creazion.de - www.happyfaces-kinderschminken.de - www.3p-consulting.com