taxonomy_node_tree.module

<?php
/* Taxonomy Node Tree Module */
/* Builds a tree based on taxonomy structure with the nodes for each term embedded */
/* A MFB Joint */
/* 07/27/10 */

/*
	Ensure max depth setting works
	Ensure starting at a specific term works
	test term & content filters 
*/

/* Implementation of hook_init() */
function taxonomy_node_tree_init() {
	if(variable_get('use_accordion', 1)){	
		drupal_add_js(drupal_get_path('module', 'taxonomy_node_tree') . '/js/taxonomy_node_tree_accordion.js');
	}	
	if(variable_get('use_taxonomy_node_tree_css', 1)){	
		drupal_add_css(drupal_get_path('module', 'taxonomy_node_tree') . '/css/taxonomy_node_tree.css');
	}
}

/**
 * Alters the block admin form to add delete links next to menu blocks.
 */
function taxonomy_node_tree_form_block_admin_display_form_alter(&$form, $form_state) {
  module_load_include('inc', 'taxonomy_node_tree', 'includes/taxonomy_node_tree.admin');
  _taxonomy_node_tree_form_block_admin_display_form_alter($form, $form_state);
}

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

	$items['admin/build/block/add-taxonomy-node-tree-block'] = array(
		'title' => 'Add taxonomy node tree block',
		'description' => 'Add a new taxonomy node tree block.',
		'access arguments' => array('administer blocks'),
		'page callback' => 'drupal_get_form',
		'page arguments' => array('taxonomy_node_tree_add_block_form'),
		'type' => MENU_LOCAL_TASK,
		'file' => 'includes/taxonomy_node_tree.admin.inc',
	);

	$items['admin/build/block/delete-taxonomy-node-tree-block'] = array(
		'title' => 'Delete taxonomy node tree block',
		'access arguments' => array('administer blocks'),
		'page callback' => 'drupal_get_form',
		'page arguments' => array('taxonomy_node_tree_delete'),
		'type' => MENU_CALLBACK,
		'file' => 'includes/taxonomy_node_tree.admin.inc',
	);

	$items['admin/settings/taxonomy-node-tree'] = array(
		'title' => 'Taxonomy Node Tree',
		'description' => 'Configure taxonomy node tree settings',
		'access arguments' => array('administer blocks'),
		'page callback' => 'drupal_get_form',
		'page arguments' => array('taxonomy_node_tree_admin_settings'),
		'type' => MENU_NORMAL_ITEM,
		'file' => 'includes/taxonomy_node_tree.admin.inc',
	);

  return $items;
}

/* Recursively iterates through the taxonomy tree, either from the beginning or */
/* starting at a certain level, and builds a nested tree of terms and the */
/* nodes attached to them */
function taxonomy_node_tree_build ( $terms = array(), $options = array(), $parents_index = array(), $current_depth = 0 ) {		

	// Get default configuration settings
	$config = taxonomy_node_tree_get_config();	

	// Get settings from options array, otherwise use defaults from config
	$parent = ( isset($options['parent']) ) ? $options['parent'] : 0;	
	$max_depth = ( isset($options['max_depth']) ) ? $options['max_depth'] : $config['max_depth'];	
	$node_visibility = ( isset($options['node_visibility']) ) ? $options['node_visibility'] : $config['node_visibility'];	
	$term_filters = ( isset($options['term_filters']) ) ? $options['term_filters'] : $config['term_filters'];	
	$content_filters['filters'] = ( isset($options['content_filters']) ) ? $options['content_filters'] : $config['content_filters'];	
	$content_filters['method'] = ( isset($options['content_filter_method']) ) ? $options['content_filter_method'] : $config['content_filter_method'];		

	// if we don't have a set of terms to work with, get the initial tree
  if (is_string($terms) || is_int($terms)) {  	
  	$vid = $terms;
    $terms = taxonomy_get_tree($vid, $parent);    
  }

  // iterate over set of terms
  foreach ($terms as $term) {
    foreach ($term->parents as $parent_tid) {
      if ($parent_tid == $parent) {
        $tree[$term->tid] = $term;
      }
      else {
        $parents_index[$parent_tid][$term->tid] = $term;
      }
    }
  }

  foreach ($tree as &$term) {
    if (isset($parents_index[$term->tid]) && (is_null($max_depth) || $current_depth < $max_depth)) {
    	$options['parent'] = $term->tid;
      $term->children = taxonomy_node_tree_build($parents_index[$term->tid], $options, $parents_index, $current_depth + 1);	      
    }

		if (taxonomy_node_tree_count_direct_node_children($term->tid, $term->vid)) {										
			$term->nodes = taxonomy_node_tree_get_term_nodes($term->tid, $content_filters);
		}	    
  }
  
  return $tree;
}

/* Generates nested ul - li markup for listing children nodes and terms based on taxonomy structure */
function taxonomy_node_tree_output ( $vid, $options, $depth = 0 ) {		
	$tree = taxonomy_node_tree_build($vid, $options);	

	$active_tids = array();
	$active_tids = taxonomy_node_tree_find_active_trail($tree, $vid);	
		
	if ($depth == 0) {
		$extra = ' tree-root';
	}
	else {
		$extra = ' tree-branch';
	}		

	$html = '<ul class="term-tree level-' . $depth . $extra . '">';

	foreach($tree as $term){
		$term_link = l($term->name, 'taxonomy/term/' . $term->tid);
		$node_tree = $term_tree = '';		
		$term_is_active = (in_array($term->tid, $active_tids));
		$term_has_children = ($term->nodes && count($term->nodes));

		if($term->nodes && count($term->nodes)){
			$node_tree = '<ul class="node-tree">';

			foreach($term->nodes as $node){ 								
				$node_item_active = ($node->in_taxonomy_active_trail);					
				$node_tree .= theme('menu_item', l($node->title, 'node/' . $node->nid), false, '', $node_item_active);
			}

			$node_tree .= '</ul>';
		}

		if($term->children && count($term->children)){
			$options['parent'] = $term->tid;
			$term_tree = taxonomy_node_tree_output($vid, $options, $depth + 1);
		}

		$html .= theme('menu_item', $term_link, $term_has_children, $node_tree . $term_tree, $term_is_active);
	}

	$html .= '</ul>';

	return $html;	
}

/**
 * Implements hook_block().
 */
function taxonomy_node_tree_block($op = 'list', $delta = NULL, $edit = NULL) {
  $function = '_taxonomy_node_tree_block_' . $op;
  if (function_exists($function)) {
    return $function($delta, $edit);
  }
  else {
    // "op"s besides "view" are seldom used, so we store them in a separate file.
    module_load_include('inc', 'taxonomy_node_tree', 'includes/taxonomy_node_tree.admin');
    if (function_exists($function)) {
      return $function($delta, $edit);
    }
  }
}

/**
 * Returns the 'view' $op info for hook_block().
 *
 * @param $delta
 *   string The name of the block to render.
 */
function _taxonomy_node_tree_block_view($delta) {
	$config = taxonomy_node_tree_get_config($delta);	

	$parent_parts = explode('-', $config['parent']);
	$vid = $parent_parts[0];
	$parent = $parent_parts[1];

	$options = array();
	
	$options['parent'] = $parent_parts[1];	
	$options['max_depth'] = $config['max_depth'];
	$options['node_visibility'] = $config['node_visibility'];	
	$options['term_filters'] = $config['term_filters'];
	$options['content_filters'] = $config['content_filters'];
	$options['content_filter_method'] = $config['content_filter_method'];	
	$options['collapse_inactive'] = $config['collapse_inactive'];
	$options['delta'] = $delta;

	$data = array();

	$data['subject'] = $config['admin_title'];
	$data['content'] = taxonomy_node_tree_output($vid, $options);		

	return $data;
}

/**
 * Returns the configuration for the requested block delta.
 *
 * @param $delta
 *   string The delta that uniquely identifies the block in the block system. If
 *   not specified, the default configuration will be returned.
 * @return
 *   array An associated array of configuration options.
 */
function taxonomy_node_tree_get_config($delta = NULL) {
  $config = array(
    'delta'       => $delta,
    'parent' => '1-0',
    'admin_title' => '',
    'max_depth'       => null,		
    'node_visibility' => 1,
		'term_filters' => array(),	
		'content_filters' => array(),	
		'content_filter_method' => 'exclude',	
		'collapse_inactive' => 0
  );

  // Get the block configuration options.
  if ($delta) {           
    $config['admin_title'] 	= variable_get("taxonomy_node_tree_{$delta}_admin_title", $config['admin_title']);
    $config['max_depth']  = variable_get("taxonomy_node_tree_{$delta}_max_depth",       $config['max_depth']);
    $config['node_visibility']   = variable_get("taxonomy_node_tree_{$delta}_node_visibility",    $config['node_visibility']);
		$config['parent'] = variable_get("taxonomy_node_tree_{$delta}_parent",    $config['parent']);
		$config['term_filters'] = variable_get("taxonomy_node_tree_{$delta}_term_filters",    $config['term_filters']);
		$config['content_filters'] = variable_get("taxonomy_node_tree_{$delta}_content_filters",    $config['content_filters']);
		$config['content_filter_method'] = variable_get("taxonomy_node_tree_{$delta}_content_filter_method",    $config['content_filter_method']);			
		$config['collapse_inactive'] = variable_get("taxonomy_node_tree_{$delta}_collapse_inactive",    $config['collapse_inactive']);	
  }

  return $config;
}

/* Helper function */
/* taxonomy_term_count_nodes() counts not just node children for the term, but also all children below it */
/* Thus, this function usefully removes the children of sub terms and gives a count of nodes for */
/* just the current term */
function taxonomy_node_tree_count_direct_node_children ( $tid, $vid ) {
	$children_nodes_count = taxonomy_term_count_nodes($tid);

	$child_terms = taxonomy_get_children($tid, $vid);		

	foreach($child_terms as $child_term){
		$sub_children_nodes_count = taxonomy_term_count_nodes($child_term->tid);	
		$children_nodes_count = $children_nodes_count - $sub_children_nodes_count;
	}		

	return $children_nodes_count;
}

/* Gets the child nodes attached directly to the given taxonomy term ID ($tid) */
/* Applies either exclusive or inclusive filters by content type, if any are set */
function taxonomy_node_tree_get_term_nodes ( $tid, $content_filters = array() ) {
	$node_children = array();

	if(module_exists('draggableviews')){	
		module_load_include('inc', 'taxonomy_node_tree', 'includes/taxonomy_node_tree.draggable');	
		if(taxonomy_node_tree_tid_has_sorted_nodes($tid, $content_filters)){
			$sorted_children = array();

			$get_sorted_nodes = taxonomy_node_tree_build_sort_query($tid, $content_filters);
			$sorted_nodes_result = db_query($get_sorted_nodes);
			while($sorted_node = db_fetch_object($sorted_nodes_result)){
				$node_child = node_load($sorted_node->nid);
				$node_children[] = $node_child;
			}
		}
	}

	$taxonomy_term_children = taxonomy_select_nodes( array( $tid ) );

	while($taxonomy_child_obj = db_fetch_object($taxonomy_term_children)){	
		$taxonomy_child_node = node_load($taxonomy_child_obj->nid);		

		if(!in_array($taxonomy_child_node, $node_children)){
			if($content_filters['filters'] && count($content_filters['filters'])){
				$is_string = (is_string($content_filters['filters'][$taxonomy_child_node->type])) ? true : false;
				$not_excluded = ($content_filters['filters'][$taxonomy_child_node->type] == 0) ? true : false;
				$is_included = ($content_filters['filters'][$taxonomy_child_node->type] == $taxonomy_child_node->type) ? true : false;
				$is_term_type = ($taxonomy_child_node->type == $content_filters['term_content_type']) ? true : false;

				switch($content_filters['method']){
					case 'exclude':
					    if( !$is_string && $not_excluded && !$is_term_type){					
							$node_children[] = $taxonomy_child_node;
						}		
						break;

					case 'include':
						if( $is_string && $is_included  && !$is_term_type){
							$node_children[] = $taxonomy_child_node;
						} 
						break;  
				}
			}
			else{
				$node_children[] = $taxonomy_child_node;
			}		
		}
	}

	return $node_children;
}

/* Provides active-trail classes based on the position of the current node in the taxonomy tree */
function taxonomy_node_tree_find_active_trail( $taxonomy_node_tree, $vid ){	
	$active_tids = array();
	$active_nid = taxonomy_node_tree_get_active_nid();

	array_walk_recursive($taxonomy_node_tree, 'taxonomy_node_tree_highlight_active_node', $active_nid);

	$deepest_tid = taxonomy_node_tree_return_most_specific_node_term($active_nid, $vid);
	$active_parents = taxonomy_get_parents_all($deepest_tid);	

	foreach($active_parents as $parent){
		$active_tids[] = $parent->tid;		
	}

	return $active_tids;
}

function taxonomy_node_tree_get_active_nid(){
	if (arg(0) == 'node' && is_numeric(arg(1))) {
	  $active_nid = arg(1);
	  return $active_nid;
	}

	return null;
}

/* Wrapper function that either retuns the only term or calls for help to find the most specific term */
function taxonomy_node_tree_return_most_specific_node_term ( $nid, $vid ){
	$node = node_load($nid);

	if(count($node->taxonomy) == 1){
		$term = end($node->taxonomy);
		return $term->tid;
	}
	else{
		$tid = taxonomy_node_tree_get_most_specific_term($node, $vid);
		return $tid;
	}
}

/* If there are multiple terms for a node, the deepest term in the tree is assumed as the most specific/applicable term */
function taxonomy_node_tree_get_most_specific_term($node, $vid){

	$terms = taxonomy_node_get_terms_by_vocabulary($node, $vid);

	$parent_counts = array();

	foreach($terms as $term){
		$parents_count = count(taxonomy_get_parents_all($term->tid));
		$parent_counts[$term->tid] = $parents_count;
	}

	if(count($parent_counts)){
		$deepest = max($parent_counts);
	}

	$tid = end(array_keys($parent_counts, $deepest));

	return $tid;	
}


/* Provides the flag that will be used to add an active class to the current node in the taxonomy node tree */
function taxonomy_node_tree_highlight_active_node($item, $key, $active_nid){
	if(is_object($item)){
		if($item->nid == $active_nid){
			$item->in_taxonomy_active_trail = true;
		}
	}	
}