modules/nodequeue/smartqueue.module

<?php
// $Id: smartqueue.module,v 1.5 2009/04/30 02:35:33 ezrag Exp $

/**
 * Implementation of hook_nodequeue_info()
 */
function smartqueue_nodequeue_info() {
  return array('smartqueue_taxonomy' => array(
    'title' => t('Taxonomy queue'),
    'description' => t('Each particular grouping of taxonomy terms from the selected vocabularies have their own unique subqueue. You can place nodes into any of these subqueues based on which terms that node has been tagged with. Using this with large or too many taxonomies may degrade performance.'),
    ));
}

/**
 * Implementation of hook_nodequeue_form()
 */
function smartqueue_taxonomy_nodequeue_form($queue, &$form) {
  foreach (taxonomy_get_vocabularies() as $vid => $vocabulary) {
    $options[$vid] = check_plain($vocabulary->name);
  }
  $form['placeholder']['vocabularies'] = array(
    '#type' => 'checkboxes',
    '#title' => t('Vocabularies'),
    '#description' => t('Select which vocabularies to use; each unique combination of terms from all of these vocabularies will have a subqueue.'),
    '#options' => $options,
  );

  $form['subqueue_title'] = array(
    '#type' => 'textfield',
    '#title' => t('Subqueue title'),
    '#default_value' => $queue->subqueue_title,
    '#size' => 50,
    '#maxlength' => 64,
    '#description' => t('What to display for the subqueue title; use %subqueue to embed the actual subqueue title. This is used to distinguish multiple nodequeues with subqueues from each other, as internal subqueue title is filled automatically.'),
  );


  if ($queue->qid) {
    $form['placeholder']['vocabularies']['#disabled'] = TRUE;
    $form['placeholder']['vocabularies']['#default_value'] = explode('-', $queue->reference);
  }
}

/**
 * Implementation of hook_nodequeue_form_validate()
 */
function smartqueue_taxonomy_nodequeue_form_validate($queue, &$form_state, &$form) {
  if (!isset($queue->qid)) {
    $vids = array_keys(array_filter($form_state['values']['vocabularies']));
    if (empty($vids)) {
      form_error($form['placeholder']['vocabularies'], t('You must select at least one vocabulary.'));
    }

    // Convert this to our reference.
    form_set_value($form['reference'], implode('-', $vids), $form_state);
  }
}


/**
 * Implementation of hook_nodequeue_subqueues()
 */
function smartqueue_taxonomy_nodequeue_subqueues(&$queue, $node) {
  foreach (explode('-', $queue->reference) as $vid) {
    $vids[$vid] = array();
  }

  foreach ($node->taxonomy as $key => $value) {
    // This unfortunate scar is needed because $node->taxonomy looks different when saving a node versus loading.
    if (!is_object($value)) {
      // $node comes from a node form submission
      foreach ((array)$value as $tid) {
        if (isset($vids[$key])) {
          $vids[$key][] = $tid;
        }
      }
    }
    else {
      // $node comes from node_load()
      if (isset($vids[$value->vid])) {
        $vids[$value->vid][] = $value->tid;
      }
    }
  }

  // Forbid NO terms being set, but allow
  // various non-terms to be set.

  $empty = TRUE;
  foreach ($vids as $vid => $tids) {
    if (!empty($tids)) {
      $empty = FALSE;
    }
    if (!count($vids[$vid])) {
      $vids[$vid][] = 0;
    }
  }

  if ($empty) {
    return;
  }

  $references = smartqueue_build_string(array_filter($vids));
  // Because of how we built this, the last one will always be all zeros. Lose it.
  //array_pop($references);

  // We're returning an array of references for efficiency, but we also have
  // to check to see if the references we've generated exist. If they don't,
  // we have to create them.
  $exists = array();
  $subqueues = nodequeue_load_subqueues_by_reference(array($queue->qid => $references));
  foreach ($subqueues as $subqueue) {
    $exists[$subqueue->reference] = TRUE;
  }

  foreach ($references as $reference) {
    if (empty($exists[$reference])) {
      nodequeue_add_subqueue($queue, smartqueue_taxonomy_nodequeue_subqueue_title($queue, $reference), $reference);
    }
  }
  return $references;
}

/**
 * Build an array of strings that represents all of the possible term
 * combinations
 */
function smartqueue_build_string($arrays) {
  $array = array_shift($arrays);
  $term = '';
  if (empty($arrays))  {
    return $array;
  }

  $substrings = smartqueue_build_string($arrays);
  $strings = array();

  foreach ($array as $term) {
    foreach ($substrings as $string) {
      $strings[] = "$term-$string";
    }
  }

  return $strings;
}

function smartqueue_taxonomy_nodequeue_subqueue_title($queue, $reference) {
  $vids = explode('-', $queue->reference);
  $tids = explode('-', $reference);
  foreach ($vids as $vid) {
    $tid = array_shift($tids);
    // $tid can be 0, specifically meaning this term is unset.
    if ($tid) {
      $terms = smartqueue_taxonomy_get_terms($vid);
      $titles[$tid] = $terms[$tid];
    }
  }
  return implode('-', $titles);
}

/**
 * Get a list of terms
 */
function smartqueue_taxonomy_get_terms($vid) {
  static $cache = array();
  if (!isset($cache[$vid])) {
    $cache[$vid] = array();
    $result = db_query("SELECT tid, name FROM {term_data} WHERE vid = %d", $vid);
    while ($term = db_fetch_object($result)) {
      $cache[$vid][$term->tid] = $term->name;
    }
  }
  return $cache[$vid];
}


// TODO:
// * Automatically add subqueues when terms are created.
// * Handle vocabulary changes (maybe?)
/**
 * Implementation of hook_taxonomy.
 */
function smartqueue_taxonomy($op, $type, $array = NULL) {
  switch ($type) {
    case 'term':
      switch ($op){
        // If a term was updated, we need to update any relevant nodequeue titles.
        case 'update':
          $tid = $array['tid'];
          // Find subqueues that contain this term.
          $result = db_query(
            "SELECT nq.reference AS reference, sq.reference AS sqref, sq.sqid
            FROM {nodequeue_queue} nq
            INNER JOIN {nodequeue_subqueue} sq ON nq.qid = sq.qid
            WHERE nq.owner = 'smartqueue_taxonomy'
            AND (sq.reference = '%d'
              OR sq.reference LIKE '%%-%d'
              OR sq.reference LIKE '%d-%%'
              OR sq.reference LIKE '%%-%d-%%')",
            $tid, $tid, $tid, $tid
          );
          while ($row = db_fetch_object($result)) {
            // Note that $row already contains the needed $row->reference.
            $title = smartqueue_taxonomy_nodequeue_subqueue_title($row, $row->sqref);
            nodequeue_subqueue_update_title($row->sqid, $title);
          }
          break;

        // If a term was deleted, we need to delete any subqueues containing it.
        case 'delete':
          $tid = $array['tid'];
          // Find subqueues that contain this term.
          $result = db_query(
            "SELECT sq.sqid FROM {nodequeue_subqueue} sq
            INNER JOIN {nodequeue_queue} nq ON sq.qid = nq.qid
            WHERE nq.owner = 'smartqueue_taxonomy'
            AND (sq.reference = '%d'
              OR sq.reference LIKE '%%-%d'
              OR sq.reference LIKE '%d-%%'
              OR sq.reference LIKE '%%-%d-%%')",
            $tid, $tid, $tid, $tid
          );
          while ($row = db_fetch_object($result)) {
            nodequeue_remove_subqueue($row->sqid);
          }
          break;
      }
    case 'vocabulary':
      break;
  }
}
1	<?php
2	// $Id: smartqueue.module,v 1.5 2009/04/30 02:35:33 ezrag Exp $
3
4	/**
5	* Implementation of hook_nodequeue_info()
6	*/
7	function smartqueue_nodequeue_info() {
8	return array('smartqueue_taxonomy' => array(
9	'title' => t('Taxonomy queue'),
10	'description' => t('Each particular grouping of taxonomy terms from the selected vocabularies have their own unique subqueue. You can place nodes into any of these subqueues based on which terms that node has been tagged with. Using this with large or too many taxonomies may degrade performance.'),
11	));
12	}
13
14	/**
15	* Implementation of hook_nodequeue_form()
16	*/
17	function smartqueue_taxonomy_nodequeue_form($queue, &$form) {
18	foreach (taxonomy_get_vocabularies() as $vid => $vocabulary) {
19	$options[$vid] = check_plain($vocabulary->name);
20	}
21	$form['placeholder']['vocabularies'] = array(
22	'#type' => 'checkboxes',
23	'#title' => t('Vocabularies'),
24	'#description' => t('Select which vocabularies to use; each unique combination of terms from all of these vocabularies will have a subqueue.'),
25	'#options' => $options,
26	);
27
28	$form['subqueue_title'] = array(
29	'#type' => 'textfield',
30	'#title' => t('Subqueue title'),
31	'#default_value' => $queue->subqueue_title,
32	'#size' => 50,
33	'#maxlength' => 64,
34	'#description' => t('What to display for the subqueue title; use %subqueue to embed the actual subqueue title. This is used to distinguish multiple nodequeues with subqueues from each other, as internal subqueue title is filled automatically.'),
35	);
36
37
38	if ($queue->qid) {
39	$form['placeholder']['vocabularies']['#disabled'] = TRUE;
40	$form['placeholder']['vocabularies']['#default_value'] = explode('-', $queue->reference);
41	}
42	}
43
44	/**
45	* Implementation of hook_nodequeue_form_validate()
46	*/
47	function smartqueue_taxonomy_nodequeue_form_validate($queue, &$form_state, &$form) {
48	if (!isset($queue->qid)) {
49	$vids = array_keys(array_filter($form_state['values']['vocabularies']));
50	if (empty($vids)) {
51	form_error($form['placeholder']['vocabularies'], t('You must select at least one vocabulary.'));
52	}
53
54	// Convert this to our reference.
55	form_set_value($form['reference'], implode('-', $vids), $form_state);
56	}
57	}
58
59
60	/**
61	* Implementation of hook_nodequeue_subqueues()
62	*/
63	function smartqueue_taxonomy_nodequeue_subqueues(&$queue, $node) {
64	foreach (explode('-', $queue->reference) as $vid) {
65	$vids[$vid] = array();
66	}
67
68	foreach ($node->taxonomy as $key => $value) {
69	// This unfortunate scar is needed because $node->taxonomy looks different when saving a node versus loading.
70	if (!is_object($value)) {
71	// $node comes from a node form submission
72	foreach ((array)$value as $tid) {
73	if (isset($vids[$key])) {
74	$vids[$key][] = $tid;
75	}
76	}
77	}
78	else {
79	// $node comes from node_load()
80	if (isset($vids[$value->vid])) {
81	$vids[$value->vid][] = $value->tid;
82	}
83	}
84	}
85
86	// Forbid NO terms being set, but allow
87	// various non-terms to be set.
88
89	$empty = TRUE;
90	foreach ($vids as $vid => $tids) {
91	if (!empty($tids)) {
92	$empty = FALSE;
93	}
94	if (!count($vids[$vid])) {
95	$vids[$vid][] = 0;
96	}
97	}
98
99	if ($empty) {
100	return;
101	}
102
103	$references = smartqueue_build_string(array_filter($vids));
104	// Because of how we built this, the last one will always be all zeros. Lose it.
105	//array_pop($references);
106
107	// We're returning an array of references for efficiency, but we also have
108	// to check to see if the references we've generated exist. If they don't,
109	// we have to create them.
110	$exists = array();
111	$subqueues = nodequeue_load_subqueues_by_reference(array($queue->qid => $references));
112	foreach ($subqueues as $subqueue) {
113	$exists[$subqueue->reference] = TRUE;
114	}
115
116	foreach ($references as $reference) {
117	if (empty($exists[$reference])) {
118	nodequeue_add_subqueue($queue, smartqueue_taxonomy_nodequeue_subqueue_title($queue, $reference), $reference);
119	}
120	}
121	return $references;
122	}
123
124	/**
125	* Build an array of strings that represents all of the possible term
126	* combinations
127	*/
128	function smartqueue_build_string($arrays) {
129	$array = array_shift($arrays);
130	$term = '';
131	if (empty($arrays)) {
132	return $array;
133	}
134
135	$substrings = smartqueue_build_string($arrays);
136	$strings = array();
137
138	foreach ($array as $term) {
139	foreach ($substrings as $string) {
140	$strings[] = "$term-$string";
141	}
142	}
143
144	return $strings;
145	}
146
147	function smartqueue_taxonomy_nodequeue_subqueue_title($queue, $reference) {
148	$vids = explode('-', $queue->reference);
149	$tids = explode('-', $reference);
150	foreach ($vids as $vid) {
151	$tid = array_shift($tids);
152	// $tid can be 0, specifically meaning this term is unset.
153	if ($tid) {
154	$terms = smartqueue_taxonomy_get_terms($vid);
155	$titles[$tid] = $terms[$tid];
156	}
157	}
158	return implode('-', $titles);
159	}
160
161	/**
162	* Get a list of terms
163	*/
164	function smartqueue_taxonomy_get_terms($vid) {
165	static $cache = array();
166	if (!isset($cache[$vid])) {
167	$cache[$vid] = array();
168	$result = db_query("SELECT tid, name FROM {term_data} WHERE vid = %d", $vid);
169	while ($term = db_fetch_object($result)) {
170	$cache[$vid][$term->tid] = $term->name;
171	}
172	}
173	return $cache[$vid];
174	}
175
176
177	// TODO:
178	// * Automatically add subqueues when terms are created.
179	// * Handle vocabulary changes (maybe?)
180	/**
181	* Implementation of hook_taxonomy.
182	*/
183	function smartqueue_taxonomy($op, $type, $array = NULL) {
184	switch ($type) {
185	case 'term':
186	switch ($op){
187	// If a term was updated, we need to update any relevant nodequeue titles.
188	case 'update':
189	$tid = $array['tid'];
190	// Find subqueues that contain this term.
191	$result = db_query(
192	"SELECT nq.reference AS reference, sq.reference AS sqref, sq.sqid
193	FROM {nodequeue_queue} nq
194	INNER JOIN {nodequeue_subqueue} sq ON nq.qid = sq.qid
195	WHERE nq.owner = 'smartqueue_taxonomy'
196	AND (sq.reference = '%d'
197	OR sq.reference LIKE '%%-%d'
198	OR sq.reference LIKE '%d-%%'
199	OR sq.reference LIKE '%%-%d-%%')",
200	$tid, $tid, $tid, $tid
201	);
202	while ($row = db_fetch_object($result)) {
203	// Note that $row already contains the needed $row->reference.
204	$title = smartqueue_taxonomy_nodequeue_subqueue_title($row, $row->sqref);
205	nodequeue_subqueue_update_title($row->sqid, $title);
206	}
207	break;
208
209	// If a term was deleted, we need to delete any subqueues containing it.
210	case 'delete':
211	$tid = $array['tid'];
212	// Find subqueues that contain this term.
213	$result = db_query(
214	"SELECT sq.sqid FROM {nodequeue_subqueue} sq
215	INNER JOIN {nodequeue_queue} nq ON sq.qid = nq.qid
216	WHERE nq.owner = 'smartqueue_taxonomy'
217	AND (sq.reference = '%d'
218	OR sq.reference LIKE '%%-%d'
219	OR sq.reference LIKE '%d-%%'
220	OR sq.reference LIKE '%%-%d-%%')",
221	$tid, $tid, $tid, $tid
222	);
223	while ($row = db_fetch_object($result)) {
224	nodequeue_remove_subqueue($row->sqid);
225	}
226	break;
227	}
228	case 'vocabulary':
229	break;
230	}
231	}