modules/taxonomy_dss/taxonomy_dss.module

<?php
// $Id: taxonomy_dss.module,v 1.25 2007/08/31 17:17:59 moonray Exp $

/* Required patch to core (can we find a module specific workaround?):

Index: themes/engines/phptemplate/phptemplate.engine
===================================================================
RCS file: /cvs/drupal/drupal/themes/engines/phptemplate/phptemplate.engine,v
retrieving revision 1.54
diff -b -U3 -r1.54 phptemplate.engine
--- themes/engines/phptemplate/phptemplate.engine   30 Dec 2006 20:59:11 -0000  1.54
+++ themes/engines/phptemplate/phptemplate.engine   25 Jan 2007 17:58:08 -0000
@@ -266,13 +266,27 @@
     $taxonomy = array();
   }

+  // This seems like a bit of a hack, but it works
+  if (isset($node->links['node_read_more'])) {
+    $link = $node->links['node_read_more'];
+
+    $href     = isset($link['href']) ? $link['href'] : NULL;
+    $query    = isset($link['query']) ? $link['query'] : NULL;
+    $fragment = isset($link['fragment']) ? $link['fragment'] : NULL;
+
+    $node_url = url($href, $query, $fragment);
+  }
+  else {
+    $node_url = url('node/'.$node->nid);
+  }
+
   $variables = array(
     'content'        => ($teaser && $node->teaser) ? $node->teaser : $node->body,
     'date'           => format_date($node->created),
     'links'          => $node->links ? theme('links', $node->links, array('class' => 'links inline')) : '',
     'name'           => theme('username', $node),
     'node'           => $node,  // we pass the actual node to allow more customization
-    'node_url'       => url('node/'. $node->nid),
+    'node_url'       => $node_url,
     'page'           => $page,
     'taxonomy'       => $taxonomy,
     'teaser'         => $teaser,

*/

/**
 * @file
 * Taxonomy Dynamic Site Structure uses taxonomy terms to create a flexible
 * and dynamic site structure, or outline.
 *
 * TODO
 *   Figure out how to let this module be loaded last if it is enabled at the
 *   same time as taxonomy; the menu callback override doesn't work otherwise.
 *   Also, find every implode that only handles commas (,) and add ability to
 *   handle plusses (+).
 */

/**
 * Implementation of hook_menu().
 */
function taxonomy_dss_menu($may_cache) {
  $items = array();

  if (!$may_cache) {
    $items[] = array(
      'path' => 'admin/content/taxonomy/settings',
      'title' => t('Settings'),
      'callback' => 'drupal_get_form',
      'callback arguments' => array('taxonomy_dss_admin_settings'),
      'access' => user_access('administer taxonomy'),
      'weight' => 10,
      'type' => MENU_LOCAL_TASK,
    );

    // Terrible hack to override taxonomy's callback function
    // Couldn't find another way to accomplish this, though
    $GLOBALS['_menu']['callbacks']['taxonomy/term']['callback'] = 'taxonomy_dss_term_page';

    // Show node view and edit/add links for taxonomy pages
    if (arg(0) == 'taxonomy' && arg(1) == 'term') {
      $node = node_load(taxonomy_dss_get_nid(arg(2)));
      $items[] = array(
        'path' => 'taxonomy/term/'. arg(2),
        'title' => t('View'),
        'callback' => 'taxonomy_dss_term_page',
        'callback arguments' => array(arg(2)),
        'access' => user_access('access content') && ($node ? node_access('view', $node) : TRUE),
        'type' => MENU_CALLBACK,
        );
      $items[] = array(
        'path' => 'taxonomy/term/'. arg(2) .'/view',
        'title' => t('View'),
        'type' => MENU_DEFAULT_LOCAL_TASK,
        'weight' => -10,
      );
      if ($node) {
        $items[] = array(
          'path' => 'taxonomy/term/'. arg(2) .'/outline',
          'title' => t('Outline'),
          'callback' => 'drupal_get_form',
          'callback arguments' => array('book_outline', $node->nid),
          'access' => user_access('outline posts in books'),
          'type' => MENU_LOCAL_TASK,
          'weight' => 2
        );
        $items[] = array(
          'path' => 'taxonomy/term/'. arg(2) .'/edit',
          'title' => t('Edit'),
          'callback' => 'taxonomy_dss_page_edit',
          'callback arguments' => array(arg(2), $node),
          'access' => node_access('update', $node),
          'weight' => 1,
          'type' => MENU_LOCAL_TASK,
        );
        $items[] = array(
          'path' => 'taxonomy/term/'. arg(2) .'/add',
          'title' => t('Edit'),
          'callback' => 'taxonomy_dss_not_available',
          'access' => node_access('update', $node),
          'weight' => 1,
          'type' => MENU_CALLBACK,
        );
        $items[] = array(
          'path' => 'taxonomy/term/'. arg(2) .'/delete',
          'title' => t('Delete'),
          'callback' => 'drupal_get_form',
          'callback arguments' => array('node_delete_confirm', $node),
          'access' => node_access('delete', $node),
          'weight' => 1,
          'type' => MENU_CALLBACK,
        );
      }
      else {
        $items[] = array(
          'path' => 'taxonomy/term/'. arg(2) .'/add',
          'title' => t('Edit'),
          'callback' => 'taxonomy_dss_page_add',
          'callback arguments' => array(arg(2)),
          'access' => node_access('create', 'term'),
          'weight' => 1,
          'type' => MENU_LOCAL_TASK,
        );
        $items[] = array(
          'path' => 'taxonomy/term/'. arg(2) .'/edit',
          'title' => t('Edit'),
          'callback' => 'taxonomy_dss_not_available',
          'access' => node_access('create', 'term'),
          'weight' => 1,
          'type' => MENU_CALLBACK,
        );
      }
    }
  }

  return $items;
}

/**
 * Menu callback; presents the taxonomy settings page.
 */
function taxonomy_dss_admin_settings() {
  $form['toc_options'] = array(
    '#type' => 'fieldset',
    '#title' => t('Default outline options'),
    '#collapsible' => TRUE,
    '#description' => t('These are the default setting which can be overridden for each individual taxonomy terms set.'),
    '#weight' => -2,
  );
  $form['toc_options']['taxonomy_dss_toc_hidden'] = array(
    '#type' => 'checkbox',
    '#title' => t('Hide outline'),
    '#default_value' => variable_get('taxonomy_dss_toc_hidden', 0),
    '#description' => t('Hide the table of contents for this set of terms.'),
  );
  $form['toc_options']['taxonomy_dss_toc_depth'] = array(
    '#type' => 'select',
    '#title' => t('Depth of outline'),
    '#default_value' => variable_get('taxonomy_dss_toc_depth', 0),
    '#options' => array(0 => 0, 1 => 1, 2 => 2, 3 => 3, 4 => 4, 5 => 5, 6 => 6, 7 => 7, 8 => 8, 9 => 9, 10 => 10),
    '#description' => t('Depth of the table of contents for this set of terms. Set this to 0 to reflect an infinite depth.'),
  );
  $form['toc_options']['taxonomy_dss_toc_nodecount'] = array(
    '#type' => 'checkbox',
    '#title' => t('Show assigned node count in outline'),
    '#default_value' => variable_get('taxonomy_dss_toc_nodecount', 1),
    '#description' => t('Toggles display of the number of assigned nodes available, for each item listed in the table of contents.'),
  );

  $form['node_options'] = array(
    '#type' => 'fieldset',
    '#title' => t('Default node listing options'),
    '#collapsible' => TRUE,
    '#collapsed' => FALSE,
    '#weight' => -1,
  );
  $form['node_options']['taxonomy_dss_lst_hidden'] = array(
    '#type' => 'checkbox',
    '#title' => t('Hide node listing'),
    '#default_value' => variable_get('taxonomy_dss_lst_hidden', 0),
    '#description' => t('Hide the listed nodes in this set of terms.'),
  );
  $form['node_options']['taxonomy_dss_lst_teasers_hidden'] = array(
    '#type' => 'checkbox',
    '#title' => t('Hide teasers'),
    '#default_value' => variable_get('taxonomy_dss_lst_teasers_hidden', 0),
    '#description' => t('Hide the teaser texts for the listed nodes in this set of terms.'),
  );

  return system_settings_form($form);
}

/**
 * Menu callback; presents the editing form associated with this set of terms,
 * or redirects to delete confirmation.
 */
function taxonomy_dss_page_edit($tid, $node) {
  if ($_POST['op'] == t('Delete')) {
    // Note: we redirect from taxonomy/term/tid/edit to taxonomy/term/tid/delete to make the tabs disappear.
    if ($_REQUEST['destination']) {
      $destination = drupal_get_destination();
      unset($_REQUEST['destination']);
    }
    drupal_goto('taxonomy/term/'. $tid .'/delete', $destination);
  }

  $terms = taxonomy_dss_terms_parse_string($tid);

  // Set page title
  $title = check_plain(end($terms['names']));
  drupal_set_title($title);

  // Set breadcrumb
  $breadcrumb = taxonomy_dss_generate_breadcrumb($terms['tids'], $terms['names']);
  taxonomy_dss_set_breadcrumb($breadcrumb);

  // Render editing form
  return drupal_get_form($node->type .'_node_form', $node);
}

/**
 * Menu callback; presents the add node form and associated a node with this
 * set of terms.
 */
function taxonomy_dss_page_add($tid) {
  $type = 'term';

  $terms = taxonomy_dss_terms_parse_string($tid);

  // Set page title
  $title = check_plain(end($terms['names']));
  drupal_set_title($title);

  // Set breadcrumb
  $breadcrumb = taxonomy_dss_generate_breadcrumb($terms['tids'], $terms['names']);
  taxonomy_dss_set_breadcrumb($breadcrumb);

  // Initialize settings:
  $node = array('uid' => $GLOBALS['user']->uid, 'name' => $GLOBALS['user']->name, 'type' => $type);

  return drupal_get_form($type .'_node_form', $node);
}

/**
 * Implementation of hook_link_alter().
 *
 * Adds query part to links in order to keep track of dynamic taxonomy based
 * site structure.
 */
function taxonomy_dss_link_alter(&$node, &$links) {
  $process = FALSE;

  if (arg(0) == 'taxonomy' && arg(1) == 'term' && isset($node->taxonomy)) {
    $tids  = taxonomy_dss_filter_tids($node->taxonomy, arg(2), TRUE);
    $process = TRUE;
  }
  elseif (arg(0) == 'node' && isset($_GET['taxonomy'])) {
    $tids = taxonomy_dss_filter_tids($node->taxonomy, $_GET['taxonomy'], TRUE);
    $process = TRUE;
  }
  elseif (arg(0) == 'comment') {
  }

  if ($process) {
    $query = (count($tids) ? 'taxonomy='. implode(',', $tids) : '');

    foreach ($links as $module => $link) {
      switch ($module) {
        case 'comment_comments':
        case 'comment_add':
        case 'node_read_more':
          if ($query) {
            $links[$module]['query'] = (isset($link['query']) ? $link['query'] . '&' : '') . $query;
          }
          break;
      }
    }
  }
}

/**
 * Implementation of hook_comment().
 *
 * Redirects the page back to the proper taxonomy term set after adding
 * a comment to a node.
 */
function taxonomy_dss_comment(&$comment, $op) {
  switch ($op) {
    case 'form':
      if (isset($_GET['taxonomy']) && !isset($comment['#attributes']['destination'])) {
        $form['destination'] = array(
          '#type'  => 'hidden',
          '#value' => 'node/'. $comment['nid']['#value'] .'?taxonomy='. $_GET['taxonomy'],
        );
      }
      elseif (isset($comment['#attributes']['destination'])) {
        $form['destination'] = array(
          '#type'  => 'hidden',
          '#value' => $comment['#attributes']['destination'],
        );
      }
      return $form;
      break;
  }
}

/**
 * Implementation of hook_form_alter().
 */
function taxonomy_dss_form_alter($form_id, &$form) {
  switch ($form_id) {
    case 'taxonomy_form_vocabulary':
      $form['taxonomy_dss_hidden'] = array(
        '#type'          => 'checkboxes',
        '#title'         => t('Breadcrumb'),
        '#default_value' => (taxonomy_dss_vocabulary_is_hidden($form['vid']['#value']) ? 1 : 0),
        '#options'       => array('1' => t('Don\'t show in breadcrumb trail')),
        '#description'   => t('The breadcrumb trail is built using terms from all vocabularies associated with the current node. The vocabulary\'s weight determines the order in which the vocabulary appears in the breadcrumb trail. If hidden, this vocabulary will not be used to build the breadcrumb trail. It is recommended to hide free tagging vocabularies.'),
        '#weight' => 1,
      );
      break;

    case 'term_node_form':
      if (arg(0) == 'node' && arg(1) == 'add') {
        $form = array();
        $form[] = array(
          '#value' => t('Term pages can only be created from a taxonomy term page.'),
        );
      }
      elseif (arg(0) == 'taxonomy' && arg(1) == 'term' && (arg(3) == 'add' || arg(3) == 'edit')) {
        // Add options for display of outline tree

        $termset = taxonomy_dss_load(arg(2));

        $form['toc_options'] = array(
          '#type' => 'fieldset',
          '#title' => t('Outline options'),
          '#collapsible' => TRUE,
          '#collapsed' => FALSE,
          '#weight' => -2,
        );
        $form['toc_options']['hidden'] = array(
          '#type' => 'checkbox',
          '#title' => t('Hide term'),
          '#default_value' => isset($node->hidden) ? $node->hidden : $termset->hidden,
          '#description' => t('Don\'t display this item in the table of contents.'),
        );
        $form['toc_options']['toc_hidden'] = array(
          '#type' => 'checkbox',
          '#title' => t('Hide outline'),
          '#default_value' => isset($node->toc_hidden) ? $node->toc_hidden : $termset->toc_hidden,
          '#description' => t('Hide the table of contents for this set of terms.'),
        );
        $form['toc_options']['toc_depth'] = array(
          '#type' => 'select',
          '#title' => t('Depth of outline'),
          '#default_value' => isset($node->toc_depth) ? $node->toc_depth : $termset->toc_depth,
          '#options' => array(0 => 0, 1 => 1, 2 => 2, 3 => 3, 4 => 4, 5 => 5, 6 => 6, 7 => 7, 8 => 8, 9 => 9, 10 => 10),
          '#description' => t('Depth of the table of contents for this set of terms. Set this to 0 to reflect an infinite depth.'),
        );
        $form['toc_options']['toc_nodecount'] = array(
          '#type' => 'checkbox',
          '#title' => t('Show assigned node count in outline'),
          '#default_value' => isset($node->toc_nodecount) ? $node->toc_nodecount : $termset->toc_nodecount,
          '#description' => t('Toggles display of the number of assigned nodes available for each item listed in the table of contents.'),
        );

        $form['node_options'] = array(
          '#type' => 'fieldset',
          '#title' => t('Node listing options'),
          '#collapsible' => TRUE,
          '#collapsed' => FALSE,
          '#weight' => -1,
        );
        $form['node_options']['lst_hidden'] = array(
          '#type' => 'checkbox',
          '#title' => t('Hide node listing'),
          '#default_value' => isset($node->lst_hidden) ? $node->lst_hidden : $termset->lst_hidden,
          '#description' => t('Hide the listed nodes in this set of terms.'),
        );
        $form['node_options']['lst_teasers_hidden'] = array(
          '#type' => 'checkbox',
          '#title' => t('Hide teasers'),
          '#default_value' => isset($node->lst_teasers_hidden) ? $node->lst_teasers_hidden : $termset->lst_teasers_hidden,
          '#description' => t('Hide the teaser texts for the listed nodes in this set of terms.'),
        );

        // Required to make this form unique to this set of terms. If omitted,
        // drupal's form handler often thinks it's a duplicate submit for a
        // previous 'add node' request.
        $form['term_tid'] = array(
          '#type' => 'hidden',
          '#value' => arg(2),
        );
      }
      else {
        print "EDIT THIS PAGE!<br />\nAdd a taxonomy select dropdown menu.<br />\nOr, we can somehow disable access to this particular page from this particular spot?";
      }
      break;

    case 'node_admin_nodes':
      // Override edit destination for 'term' nodes on 'Content management' page
      if (is_array($form['name'])) {
        $keys = array_keys($form['name']);
        foreach ($keys as $key) {
          if ($form['name'][$key]['#value'] == 'Term') {
            $form['operations'][$key]['#value'] = l(t('edit'), 'taxonomy/term/'. taxonomy_dss_get_tids($key) .'/edit', array(), drupal_get_destination());
          }
        }
      }
      break;
  }
}

/**
 * Implementation of hook_taxonomy().
 */
function taxonomy_dss_taxonomy($op, $type, $object = NULL) {
  if ($type == 'vocabulary') {
    switch ($op) {
      case 'delete':
        db_query("DELETE FROM {taxonomy_dss_vocabulary} WHERE vid = %d", $object['vid']);
        break;
      case 'insert':
        db_query("INSERT INTO {taxonomy_dss_vocabulary} (vid, hidden) VALUES (%d, %d)", $object['vid'], $object['taxonomy_dss_hidden']['1']);
        break;
      case 'update':
        db_query("UPDATE {taxonomy_dss_vocabulary} SET hidden = %d WHERE vid = %d", $object['taxonomy_dss_hidden']['1'], $object['vid']);
        break;
    }
  }
  elseif ($type == 'term') {
    switch ($op) {
      case 'delete':
        db_query("DELETE FROM {taxonomy_dss_term} WHERE tid = '%s'", $object['tid']);
        // Actually, we need to delete every single page that this term appears in... ouch!
        break;
    }
  }
}

/**
 * Implementation of hook_nodeapi().
 */
function taxonomy_dss_nodeapi(&$node, $op, $teaser, $page) {
  $clean_url = (bool)variable_get('clean_url', '0');
  $delimiter = ($clean_url == FALSE || strstr('?', $node->breadcrumb[$i]['path']) ? '&' : '?');

  switch ($op) {
    case 'insert':
      if (arg(0) == 'taxonomy' && arg(1) == 'term' && arg(3) == 'add') {
        // arg(2) needs to be cleaned, or we might have a security hole!

        // Allow other modules to alter the data
        $termset = taxonomy_dss_node_to_termset(arg(2), $node);
        taxonomy_dss_invoke($termset, 'submit', $node);
        $termset->serialized_data = serialize($termset->serial_data);

        // Insert termset into database
        db_query("INSERT INTO {taxonomy_dss_term} (tid, nid, hidden, toc_hidden, toc_depth, toc_nodecount, lst_hidden, lst_teasers_hidden, serialized_data) VALUES ('%s', %d, %d, %d, %d, %d, %d, %d, '%s')", $termset->tids, $termset->nid, $termset->hidden, $termset->toc_hidden, $termset->toc_depth, $termset->toc_nodecount, $termset->lst_hidden, $termset->lst_teasers_hidden, $termset->serialized_data);

        // Allow other modules to alter the data
        taxonomy_dss_invoke($termset, 'insert', $node);
      }
      break;

    case 'update':
      if (arg(0) == 'taxonomy' && arg(1) == 'term' && arg(3) == 'edit') {

        // Allow other modules to alter the data
        $termset = taxonomy_dss_node_to_termset(arg(2), $node);
        taxonomy_dss_invoke($termset, 'submit', $node);
        $termset->serialized_data = serialize($termset->serial_data);

        // Update termset in database
        db_query("UPDATE {taxonomy_dss_term} SET hidden = %d, toc_hidden = %d, toc_depth = %d, toc_nodecount = %d, lst_hidden = %d, lst_teasers_hidden = %d, serialized_data = '%s' WHERE tid = '%s'", $termset->hidden, $termset->toc_hidden, $termset->toc_depth, $termset->toc_nodecount, $termset->lst_hidden, $termset->lst_teasers_hidden, $termset->serialized_data, $termset->tids);

        // Allow other modules to alter the data
        taxonomy_dss_invoke($termset, 'update', $node);
      }
      break;

    case 'delete':
      db_query("DELETE FROM {taxonomy_dss_term} WHERE nid = %d", $node->nid);

      // Allow other modules to alter the data
      taxonomy_dss_invoke($termset, 'delete');
      break;

    case 'submit':
      // If it's a term node, add a title
      if (isset($node->nid)) {
        // Updating existing node
        if ($node->type == 'term' && $tids = taxonomy_dss_get_tids($node->nid)) {
          $node->title = taxonomy_dss_get_title($tids);
        }
      }
      elseif (arg(0) == 'taxonomy' && arg(1) == 'term' && arg(3) == 'add') {
        // Creating new node
        $node->title = taxonomy_dss_get_title(arg(2));
      }

      break;

    case 'view':
      if ($page) {
        // Page view

        // If this node is associated with a taxonomy term, jump!
        if (arg(0) != 'taxonomy' && arg(1) != 'term' && $tid = taxonomy_dss_get_tids($node->nid)) {
          drupal_goto('taxonomy/term/'.$tid);
        }

        // Fix book module links
        $taxonomy = $_GET['taxonomy'] ? 'taxonomy='.$_GET['taxonomy'] : '';
        if (module_exists('book') && isset($node->content['book_navigation']) && $taxonomy) {
          // Hack the themed output from the book module's navigation
          $node->content['book_navigation'] = preg_replace('/(node\/\d+)/', '${1}'. $delimiter.$taxonomy, $node->content['book_navigation']);
        }

        // Taxonomy terms seem to already be sorted by vocabulary weight.
        $tids  = taxonomy_dss_filter_tids($node->taxonomy, $_GET['taxonomy']);
        $names = array();
        foreach ($tids as $tid) {
          $names[] = $node->taxonomy[$tid]->name;
        }

        $breadcrumb = taxonomy_dss_generate_breadcrumb($tids, $names);

        // Integrate with book module
        if (module_exists('book') && isset($node->breadcrumb)) {
          $breadcrumb = array_merge($breadcrumb, $node->breadcrumb);
        }
        else {
          $breadcrumb[] = array('path' => 'node/'. $node->nid, 'title' => $node->title);
        }

        menu_set_location($breadcrumb);
        taxonomy_dss_set_breadcrumb($breadcrumb);
      }
      break;
    case 'alter':
      if ($page) {
        // Page view

        $taxonomy = $_GET['taxonomy'] ? 'taxonomy='.$_GET['taxonomy'] : '';

        if (module_exists('book') && isset($node->breadcrumb) && $taxonomy) {
          // Hack the breadcrumb to include the query
          $breadcrumb = drupal_get_breadcrumb();
          $offset       = count($breadcrumb) - count($node->breadcrumb) + 1;
          for ($i = $offset; $i < count($breadcrumb); $i++) {
            $breadcrumb[$i] = str_replace($node->breadcrumb[$i - $offset]['path'], $node->breadcrumb[$i - $offset]['path'] . $delimiter . $taxonomy, $breadcrumb[$i]);
          }
          drupal_set_breadcrumb($breadcrumb);
        }
      }
      break;
  }
}

/**
 * Is vocabulary hidden?
 */
function taxonomy_dss_vocabulary_is_hidden($vid) {
  static $vocabularies = array();

  if (!isset($vocabularies[$vid])) {
    $result = db_query("SELECT hidden FROM {taxonomy_dss_vocabulary} WHERE vid = %d", $vid);
    $row = db_fetch_array($result);
    if ($row && $row['hidden'] == 1) {
      $vocabularies[$vid] = TRUE;
    }
    else {
      $vocabularies[$vid] = FALSE;
    }
  }

  return $vocabularies[$vid];
}

function taxonomy_dss_not_available() {
  return t('n/a');
}

function taxonomy_dss_get_termset_data($tids) {
  static $data = array();

  if (!isset($data[$tids])) {
    $result = db_query("SELECT nid, hidden, toc_hidden, toc_depth, toc_nodecount, lst_hidden, lst_teasers_hidden, serialized_data FROM {taxonomy_dss_term} WHERE tid = '%s'", $tids);
    if ($row = db_fetch_object($result)) {
      $row->serial_data = unserialize($row->serialized_data);
      $data[$tids] = $row;
    }
    else {
      $data[$tids] = new StdClass;
      $data[$tids]->tids = $tids;
      $data[$tids]->nid = 0;
      $data[$tids]->hidden = 0;
      $data[$tids]->toc_hidden = variable_get('taxonomy_dss_toc_hidden', 0);
      $data[$tids]->toc_depth = variable_get('taxonomy_dss_toc_depth', 0);
      $data[$tids]->toc_nodecount = variable_get('taxonomy_dss_toc_nodecount', 1);
      $data[$tids]->lst_hidden = variable_get('taxonomy_dss_lst_hidden', 0);
      $data[$tids]->lst_teasers_hidden = variable_get('taxonomy_dss_lst_teasers_hidden', 0);
      $data[$tids]->serial_data = unserialize('');
    }
  }

  return drupal_clone($data[$tids]);
}

function taxonomy_dss_term_is_hidden($tids) {
  $termset = taxonomy_dss_load($tids);
  return $termset->hidden;
}

function taxonomy_dss_get_nid($tids) {
  $termset = taxonomy_dss_load($tids);
  return $termset->nid;
}

function taxonomy_dss_get_tids($nid) {
  $tids = 0;

  $result = db_query("SELECT tid FROM {taxonomy_dss_term} WHERE nid = %d", $nid);
  if ($row = db_fetch_array($result)) {
    $tids = $row['tid'];
  }
  return $tids;
}

function taxonomy_dss_get_current_tids() {
  $tids = array();
  switch (arg(0)) {
    case 'node':
      if (is_numeric(arg(1))) {
        $node = node_load(arg(1));
        if (!$node) {
          break;
        }
        $tids = taxonomy_dss_filter_tids($node->taxonomy, isset($_GET['taxonomy']) ? $_GET['taxonomy'] : '');
      }
      break;
    case 'taxonomy':
      if (arg(1) == 'term') {
        $tids = explode(',', arg(2));
      }
      break;
    case 'faq':
      if (module_exists('faq') && module_exists('path_redirect')) {
        $result = db_query("SELECT path FROM {path_redirect} WHERE redirect = '%s'", 'faq');
        while ($row = db_fetch_array($result)) {
          if (substr($row['path'], 0, 14) == 'taxonomy/term/') {
            $names = array();
            $tids = explode(',', substr($row['path'], 14));
          }
        }
      }
      break;
  }

  return $tids;
}

/**
 * Extends taxonomy_terms_parse_string.
 * Parses a comma or plus separated string of term IDs.
 *
 * @param $str_tids
 *   A string of term IDs, separated by plus or comma.
 *   comma (,) means AND.
 *   plus (+) means OR.
 * @param $expand_parents
 *   (optional) Expands tids that have parents when TRUE. Defaults to FALSE.
 *
 * @return an associative array with an operator key (either 'and' or 'or'),
 *   a tids key containing an array of the term ids, and a names key
 *   containing the term names/titles.
 */
function taxonomy_dss_terms_parse_string($str_tids, $expand_parents = FALSE) {
  static $termsets = array(
    'default' => array(),
    'expanded' => array(),
  );

  if ($expand_parents === FALSE) {
    if (isset($termsets['default'][$str_tids])) {
      return $termsets['default'][$str_tids];
    }
  }
  else {
    if (isset($termsets['expanded'][$str_tids])) {
      return $termsets['expanded'][$str_tids];
    }
  }

  // Parse string
  $terms = taxonomy_terms_parse_string($str_tids);
  if ($terms['operator'] != 'and' && $terms['operator'] != 'or') {
    drupal_not_found();
  }

  // Expand to include parents
  if ($expand_parents) {
    $tids = array();

    foreach ($terms['tids'] as $tid) {
      if ($parents = taxonomy_get_parents_all($tid)) {
        while (count($parents)) {
          $parent = array_pop($parents);
          $tids[] = $parent->tid;
        }
      }
      $tids[] = $tid;
    }

    $terms['tids'] = $tids;
  }

  // Retrieve the name for each term
  if ($terms['tids']) {
    $tids  = array();
    $names = array();

    $result = db_query(db_rewrite_sql('SELECT t.tid, t.name, (%s) AS weight FROM {term_data} t WHERE t.tid IN (%s) ORDER BY weight', 't', 'tid'), _taxonomy_dss_sql_order_tids($terms['tids']), implode(',', $terms['tids']));
    while ($term = db_fetch_object($result)) {
      $tids[]  = $term->tid;
      $names[] = $term->name;
    }

    $terms['tids']  = $tids;
    $terms['names'] = $names;
  }

  if ($expand_parents === FALSE) {
    $termsets['default'][$str_tids] = $terms;
    return $termsets['default'][$str_tids];
  }
  else {
    $termsets['expanded'][$str_tids] = $terms;
    return $termsets['expanded'][$str_tids];
  }
}

/**
 * Derives title from a comma or plus separated string of term IDs.
 *
 * @param $str_tids
 *   A string of term IDs, separated by plus or comma.
 *   comma (,) means AND.
 *   plus (+) means OR.
 *
 * @return the derived title string.
 **/
function taxonomy_dss_get_title($str_tids) {
  $terms = taxonomy_dss_terms_parse_string($str_tids, TRUE);
  $title = implode(' › ', $terms['names']);

  return $title;
}

/**
 * Given an array of taxonomy terms, this function will validate it against
 * a set of term IDs and strip out invalid ones. By default it will also strip
 * out hidden terms.
 *
 * @param $taxonomy
 *   An array of taxonomy terms to be filtered.
 * @param $tids
 *   An array of the valid taxonomy term IDs.
 * @param $minimal
 *   (optional) When TRUE, this function will look at the weights of each term
 *   and its vocabulary, and remove the terms that are in the right order.
 *   Defaults to FALSE.
 * @param $strip_hidden
 *   (optional) Strips hidden vocabularies when TRUE. Defaults to TRUE.
 *
 * @return
 *   An array of taxonomy term IDs, with hidden and excess terms stripped out.
 */
function taxonomy_dss_filter_tids($taxonomy, $tids = array(), $minimal = FALSE, $strip_hidden = TRUE) {
  // Strip out other terms from the same vocabulary
  $strip_same_vocabulary = TRUE;

  $return = array();

  if (count($taxonomy) == 0) {
    return $return;
  }

  if (!is_array($tids)) {
    if ($tids) {
      $terms = taxonomy_dss_terms_parse_string($tids);
      $tids = $terms['tids'];
    }
    else {
      $tids = array();
    }
  }

  $vids = array();
  $keys = array_keys($taxonomy);

  // Filter out invalid and hidden tids
  for ($i = 0; $i < count($tids); $i++) {
    /*
    // If the term's vocabulary is hidden, don't return it
    if ($strip_hidden) {
      // Is this a valid tid?
      if (in_array($tids[$i], $keys)) {
        $term = $taxonomy[$tids[$i]];

        // Cache vocabulary data
        if (!isset($vids[$term->vid])) {
          $vids[$term->vid] = taxonomy_dss_vocabulary_is_hidden($term->vid);
        }

        // Only return tid if it's not hidden
        if ($vids[$term->vid] == FALSE) {
          $return[]  = $term->tid;
        }
      }
    }
    else {
    */
      // Is this a valid tid?
      if (in_array($tids[$i], $keys)) {
        $term = $taxonomy[$tids[$i]];

        if (!isset($vids[$term->vid])) {
          if ($strip_hidden) {
            $vids[$term->vid] = taxonomy_dss_vocabulary_is_hidden($term->vid);
          }
          else {
            $vids[$term->vid] = FALSE;
          }
        }
        $return[] = $tids[$i];
      }
    /*
    }
    */
  }

  // Filter out hidden tids, and add the remaining ones
  for ($i = 0; $i < count($keys); $i++) {
    if (!in_array($keys[$i], $return)) {
      $term = $taxonomy[$keys[$i]];

      if ($strip_hidden) {
        // Cache vocabulary data
        if (!isset($vids[$term->vid])) {
          $vids[$term->vid] = taxonomy_dss_vocabulary_is_hidden($term->vid);
          if ($strip_same_vocabulary == TRUE && $vids[$term->vid] == FALSE) {
            $return[]  = $term->tid;
          }
        }

        // Only return tid if it's not hidden
        if ($strip_same_vocabulary == FALSE && $vids[$term->vid] == FALSE) {
          $return[]  = $term->tid;
        }
      }
      else {
        if ($strip_same_vocabulary) {
          if (!isset($vids[$term->vid])) {
            $vids[$term->vid] = FALSE;
            $return[] = $keys[$i];
          }
        }
        else {
          $return[] = $keys[$i];
        }
      }
    }
  }

  // Filter out redundant tids (tids that are already in order of weight)
  if ($minimal) {
    for ($i = count($keys) -1; $i >= 0; $i--) {
      if ($return[$i] == $keys[$i]) {
        array_pop($return);
      }
    }
  }

  return $return;
}

function taxonomy_dss_select_children($tids) {
  if (!is_array($tids) && is_numeric($tids)) {
    $tids = array($tids);
  }
  if (count($tids) > 0) {
    $joins = '';
    $wheres = '';
    foreach ($tids as $index => $tid) {
      $joins  .= ' INNER JOIN {term_node} tn'. $index .' ON n.nid = tn'. $index .'.nid';
      $wheres .= ' AND tn'. $index .'.tid = '. $tid;
    }
    $sql = "SELECT DISTINCT(n.nid) FROM {node} n {$joins} WHERE n.status = 1 {$wheres} AND (SELECT COUNT(DISTINCT td0.vid) FROM {term_node} t LEFT JOIN {term_data} td0 ON t.tid = td0.tid WHERE t.nid = n.nid) > ". count($tids);

    $sql = "SELECT tn.nid, tn.tid, td.vid, td.name, td.description, td.weight, v.weight AS vweight FROM {term_node} tn LEFT JOIN {term_data} td ON td.tid = tn.tid LEFT JOIN {vocabulary} v ON td.vid = v.vid WHERE tn.nid IN ({$sql}) AND td.vid NOT IN (SELECT td1.vid FROM {term_data} td1 WHERE td1.tid IN (". implode(',', $tids) .")) ORDER BY v.weight DESC, td.weight DESC, td.name DESC";

    $sql = "SELECT DISTINCT r.tid, r.vid, r.name, r.description, r.weight, GROUP_CONCAT(DISTINCT r.tid ORDER BY r.vweight, r.weight, r.name SEPARATOR ',') AS tids FROM ({$sql}) r GROUP BY r.nid ORDER BY r.vweight, r.weight, r.name";

    $result = db_query(db_rewrite_sql($sql, 'tn', 'randomfieldname'));
  }

  return $result;
}

function taxonomy_dss_get_tree_children($tids, &$result, $depth = 0) {
  $children = array();

  // Get all child terms
  $child_terms = taxonomy_get_children(end($tids));

  // Add all children from other vocabularies
  if (db_num_rows($result) > 0) {
    while ($term = db_fetch_object($result)) {
      $child_terms[] = $term;
    }
  }

  foreach ($child_terms as $child) {
    // Create a new tids array
    $mytids = $tids;

    // Fix for child terms (not child terms from other vocabularies)
    if (!isset($child->tids)) {
      array_pop($mytids);
    }

    $child->nodes    = array();

    // Is child a sub of other child(ren)?
    if (strpos($child->tids, ',') !== FALSE) {
      $atids = explode(',', $child->tids);

      $mychildren = &$children;
      while (count($atids) > 1) {
        $tid = array_shift($atids);
        array_push($mytids, $tid);

        if (!isset($mychildren[$tid])) {
          // Fetch missing term
          $term = taxonomy_get_term($tid);

          $term->count    = _taxonomy_dss_count_nodes($mytids);
          // $term->children = array();
          $term->nodes    = array();
          $term->pids   = $mytids;
          $term->link     = 'taxonomy/term/'. implode(',', $mytids);
          $term->hidden   = taxonomy_dss_term_is_hidden(implode(',', $mytids));

          $mychildren[$tid] = $term;
        }

        // Handle terms from the same vocabulary
        $next_term = taxonomy_get_term($atids[0]);
        if ($mychildren[$tid]->vid !== $next_term->vid) {
          if (!isset($mychildren[$tid]->children)) {
            $mychildren[$tid]->children = array();
          }
          $mychildren = &$mychildren[$tid]->children;
        }
        else {
          array_pop($mytids);
        }

      }

      // Add details
      array_push($mytids, $child->tid);
      $child->count  = _taxonomy_dss_count_nodes($mytids);
      $child->pids   = $mytids;
      $child->link   = 'taxonomy/term/'. implode(',', $mytids);
      $child->hidden = taxonomy_dss_term_is_hidden(implode(',', $mytids));

      // Parent node should already be created
      $mychildren[$child->tid] = $child;
    }
    else {
      // Add details
      array_push($mytids, $child->tid);
      $child->count = _taxonomy_dss_count_nodes($mytids);

      if (count($tids) == 1 || $child->count > 0) {
        $child->pids   = $mytids;
        $child->link   = 'taxonomy/term/'. implode(',', $mytids);
        $child->hidden = taxonomy_dss_term_is_hidden(implode(',', $mytids));

        if (!isset($child->tids)) {
          $mychildren = taxonomy_dss_get_tree_children($mytids, taxonomy_dss_select_children($mytids), 0);
          if (count($mychildren)) {
            $child->children = $mychildren;
          }
        }

        // Normal child, not a sub-child
        $children[$child->tid] = $child;
      }
    }
  }

  // Expand terms to include parent terms
  _taxonomy_dss_expand_terms($children, $tids);

  // Strip anything that's in a deeper level than requested
  if ($depth > 0) {
    _taxonomy_dss_limit_depth($children, $depth);
  }

  // Sort terms by weight: first by vocabulary weight, then by individual term weights
  _taxonomy_dss_sort_tree($children);

  return $children;
}

/**
 * Replacement for taxonomy_select_nodes.
 * Finds all nodes that match selected taxonomy conditions.
 *
 * @param $tids
 *   An array of term IDs to match.
 * @param $operator
 *   How to interpret multiple IDs in the array. Can be "or" or "and".
 * @param $depth
 *   How many levels deep to traverse the taxonomy tree. Can be a nonnegative
 *   integer or "all".
 * @param $pager
 *   Whether the nodes are to be used with a pager (the case on most Drupal
 *   pages) or not (in an XML feed, for example).
 * @param $order
 *   The order clause for the query that retrieve the nodes.
 * @return
 *   A resource identifier pointing to the query results.
 */
function taxonomy_dss_select_nodes($tids = array(), $operator = 'or', $depth = 0, $pager = TRUE, $order = 'n.sticky DESC, n.created DESC', $exclusive = TRUE, $promoted = FALSE, $nodecount = 0) {
  if (count($tids) > 0) {
    // For each term ID, generate an array of descendant term IDs to the right depth.
    $descendant_tids = array();
    if ($depth === 'all') {
      $depth = NULL;
    }
    foreach ($tids as $index => $tid) {
      $term = taxonomy_get_term($tid);
      $tree = taxonomy_get_tree($term->vid, $tid, -1, $depth);
      $descendant_tids[] = array_merge(array($tid), array_map('_taxonomy_get_tid_from_term', $tree));
    }

    $promote_sql = $promoted ? 'AND n.promote = 1 ' : '';

    if ($operator == 'or') {
      $str_tids = implode(',', call_user_func_array('array_merge', $descendant_tids));
      $sql = 'SELECT DISTINCT(n.nid), n.sticky, n.title, n.created FROM {node} n INNER JOIN {term_node} tn ON n.nid = tn.nid WHERE tn.tid IN ('. $str_tids .') '. $promote_sql .'AND n.status = 1 ORDER BY '. $order;
      $sql_count = 'SELECT COUNT(DISTINCT(n.nid)) FROM {node} n INNER JOIN {term_node} tn ON n.nid = tn.nid WHERE tn.tid IN ('. $str_tids .') '. $promote_sql .'AND n.status = 1';
    }
    else {
      $joins = '';
      $wheres = '';
      foreach ($descendant_tids as $index => $tids) {
        $joins .= ' INNER JOIN {term_node} tn'. $index .' ON n.nid = tn'. $index .'.nid';
        $wheres .= ' AND tn'. $index .'.tid IN ('. implode(',', $tids) .')';
      }
      if ($exclusive) {
        $sql = 'SELECT DISTINCT(n.nid), n.sticky, n.title, n.created FROM {node} n '. $joins .' WHERE n.status = 1 '. $promote_sql . $wheres .' AND (SELECT COUNT(DISTINCT td0.vid) FROM {term_node} t LEFT JOIN {term_data} td0 ON t.tid = td0.tid WHERE t.nid = n.nid) = '. count($descendant_tids) .' ORDER BY '. $order;
        $sql_count = 'SELECT COUNT(DISTINCT(n.nid)) FROM {node} n '. $joins .' AND (SELECT COUNT(*) FROM {term_node} t WHERE t.nid = n.nid) = '. count($descendant_tids) .' WHERE n.status = 1 '. $promote_sql . $wheres;
      }
      else {
        $sql = 'SELECT DISTINCT(n.nid), n.sticky, n.title, n.created FROM {node} n '. $joins .' WHERE n.status = 1 '. $promote_sql . $wheres .' ORDER BY '. $order;
        $sql_count = 'SELECT COUNT(DISTINCT(n.nid)) FROM {node} n '. $joins .' WHERE n.status = 1 '. $promote_sql . $wheres;
      }
    }
    // Once Taxonomy Acccess Control or any other acces control module gets
    // enabled, it tries to mess with the SQL unless you set the fieldname to
    // something it doesn't recognize.
    $sql = db_rewrite_sql($sql, 'tn', 'randomfieldname');
    $sql_count = db_rewrite_sql($sql_count, 'tn', 'randomfieldname');

    if ($pager) {
      if ($nodecount == 0) {
        $nodecount = variable_get('default_nodes_main', 10);
      }
      $result = pager_query($sql, $nodecount, 0, $sql_count);
    }
    else {
      if ($nodecount == 0) {
        $nodecount = variable_get('feed_default_items', 10);
      }
      $result = db_query_range($sql, 0, $nodecount);
    }