TaxonomyManager Class Reference

TaxonomyManager provides the internal API for working with taxonomies, facets and bindings. More...

Public Member Functions
	__construct ()
	Create a new TaxonomyManager instance. More...

Static Public Member Functions
static	setDefaults ()
static	getTabs ($key)
static	getRegisteredClasses ()
	Retrieved the list of DataItem classes that have registered as supporting taxonomy term associations. More...
static	getRegisteredClassOptions ()
	Retrieves the list of DataItem classes that have registered as supporting taxonomy term associations in an associated array format suitable for use with a SelectFieldRenderer or CheckListFieldRenderer. More...
static	getBindableClasses ()
static	registerBindableClass ($class, $format, $constraint="", $fieldRenderer=BindingTargetFieldRenderer, $facetFilter=BindingTargetFacetFilter)
static	getBindableClassOptions ()
static	getBindingOptions ($bindingTarget)
static	getBindingOptionFormat ($bindingTarget)
static	getBindingFieldRendererClass ($bindingTarget)
static	getBindingFacetFilterClass ($bindingTarget)
static	addTaxonomyFieldRenderers ($form, $showSelectAll=true, $group=null, $limitTo=null)
static	addBindingFieldRenderers ($form, $showSelectAll=true, $group=null)
static	getAssociatedTaxonomies ($classes, $facet_filter_only=false)
static	getBindingTargets ($classes, $facet_filter_only=false)
static	importTerms ($taxonomy, $file)
static	addFacets ($manager, $classes, $dropdown=true, $max_width="200px", $width="200px", $height="120px")
static	getRequestTerms ($classes)
static	getRequestFilterConstraint ($class)
static	cloneTaxonomy ($form)
static	getBoundItems ($source, $class, $constraint="")
	Retrieve items of the specified class that are bound to the specified source object. More...
static	getBoundItemsReverse ($target, $class, $constraint="")
	Same as TaxonomyManager::getBoundItems, but with the reverse relationship. More...
static	countBoundItems ($target, $class, $constraint="")
	Returns the number of items of the specified class that are bound to the specified source object. More...
static	countBoundItemsReverse ($target, $class, $constraint="")
	Same as TaxonomyManager::countBoundItems, but with the reverse relationship. More...
static	generateSearchConstraint ($text, $class, $placeholder=false)
	Generates a search constraint matching the supplied text against taxonomy terms that might be associated with the given class. More...
static	upgradeComponent ($version)
static	registerSerializationHandler ()

Static Public Attributes
static	$bindableClasses = null

Detailed Description

TaxonomyManager provides the internal API for working with taxonomies, facets and bindings.

These methods are designed to bridge the gap between the user-extensible taxonomy schemas and the defined items in your data model. TaxonomyManager also provides event handlers and common functionality for the taxonomy component.

Definition at line 90 of file taxonomy_manager.inc.

Constructor & Destructor Documentation

__construct()

TaxonomyManager::__construct

(

)

Create a new TaxonomyManager instance.

Generally not required as all methods are static.

Definition at line 98 of file taxonomy_manager.inc.

     {
 
     }

Member Function Documentation

addBindingFieldRenderers()

static TaxonomyManager::addBindingFieldRenderers (   $form,   $showSelectAll = true,   $group = null  )

static

Definition at line 259 of file taxonomy_manager.inc.

     {
          TaxonomyManager::getBindableClasses();
          
          $class = get_class($form->data);
          
          $targets = Query::create(BindingTarget, "")->execute();
          
          trace("### Found ".count($targets)." binding targets", 3);
          $renderers = array();
          
          foreach($targets as $target)
          {
               trace("## Checking {$target->target_class} - {$target->associated_classes}", 3);
               
               $classes = explode(",", $target->associated_classes);
               if (array_search($class, $classes) !== FALSE)
               {
                    trace("## Found a match", 3);
                    
                    $fieldRenderer = TaxonomyManager::getBindingFieldRendererClass($target);
                    
                    $renderer = new $fieldRenderer($form, $target);
                    $renderer->setSize(400, 125);
                    $renderer->resizable = true;
                    $renderer->showSelectAll = $showSelectAll;
          
                    if ($group)
                    {
                         $form->group($group, $class);
                    }
          
                    $renderers[] = $renderer;
               }
          }
          
          return $renderers;
     }

addFacets()

static TaxonomyManager::addFacets (   $manager,   $classes,   $dropdown = true,   $max_width = "200px",   $width = "200px",   $height = "120px"  )

static

Definition at line 418 of file taxonomy_manager.inc.

     {
          if (!is_array($classes) && $classes) $classes = array($classes);
          
          $bindingTargets = TaxonomyManager::getBindingTargets($classes, true);
          foreach($bindingTargets as $target)
          {
               $facetFilter = TaxonomyManager::getBindingFacetFilterClass($target);
               
               $facet = $manager->addFacet($target->target_class, new $facetFilter($target));
               $facet->dropdown = $dropdown;
               $facet->dropdownMaxWidth = $max_width;
               $facet->width = $width;
               $facet->height = $height;
          }
               
          $taxonomies = TaxonomyManager::getAssociatedTaxonomies($classes, true);
          foreach($taxonomies as $taxonomy)
          {
               $facet = $manager->addFacet($taxonomy->taxonomy_name, new TaxonomyFacetFilter($taxonomy));
               $facet->dropdown = $dropdown;
               $facet->dropdownMaxWidth = $max_width;
               $facet->width = $width;
               $facet->height = $height;
          }
     }

addTaxonomyFieldRenderers()

static TaxonomyManager::addTaxonomyFieldRenderers (   $form,   $showSelectAll = true,   $group = null,   $limitTo = null  )

static

Definition at line 217 of file taxonomy_manager.inc.

     {
          $renderers = TaxonomyManager::addBindingFieldRenderers($form, $showSelectAll, $group, $limitTo);
          
          $class = get_class($form->data);
          
          $taxonomies = Query::create(Taxonomy, "")->execute();
          
          foreach($taxonomies as $taxonomy)
          {
               $classes = explode(",", $taxonomy->associated_classes);
               if (array_search($class, $classes) !== FALSE)
               {
                    if (is_array($limitTo) && !array_search($taxonomy->identifier, $limitTo))
                    {
                         continue;
                    }
                    
                    trace("Adding TaxonomyTermFieldRenderer for {$taxonomy->identifier}", 3);
                    $renderer = new TaxonomyTermFieldRenderer($form, $taxonomy);
                    $renderer->setSize(400, 125);
                    $renderer->resizable = true;
                    $renderer->showSelectAll = $showSelectAll;
                    
                    if ($group)
                    {
                         $form->group($group, $taxonomy->identifier);
                    }
                    
                    if ($form instanceof SearchForm)
                    {
                         $form->params->setHandler($taxonomy->identifier, new TaxonomySearchParameterHandler($class));
                         $form->setMatchingMode("member", $taxonomy->identifier);
                    }
                    
                    $renderers[] = $renderer;
               }
          }
          
          return $renderers;
     }

cloneTaxonomy()

static TaxonomyManager::cloneTaxonomy (   $form )

static

Definition at line 499 of file taxonomy_manager.inc.

     {
          $tx = new DataTransaction();
          
          try 
          {
               $clone = $form->data;
               
               $clone->joinTransaction($tx);
               
               $clone->filter = null;
               $name = $clone->taxonomy_name;
               $ident = $clone->identifier;
               
               $taxonomy_id = checkNumeric($_GET["taxonomy_id"]);
               $src = new Taxonomy($taxonomy_id);
               $clone->copy($src);
               unset($clone->taxonomy_id);
               $clone->taxonomy_name = $name;
               $clone->identifier = $ident;
               $clone->published = false;
               $clone->save();
     
               $terms = $src->Terms();
 
               foreach($terms as $term)
               {
                    $cloneTerm = new TaxonomyTerm();
                    $cloneTerm->copy($term);
                    $cloneTerm->taxonomy_id = $clone->taxonomy_id;
                    unset($cloneTerm->term_id);
                    $cloneTerm->joinTransaction($tx);
                    $cloneTerm->save();
               }
               
               $tx->commit();
               return true;
          }
          catch (Exception $e)
          {
               $tx->rollback();
               $form->msg = $e->getMessage();
               return false;
          }
     }

countBoundItems()

static TaxonomyManager::countBoundItems (   $target,   $class,   $constraint = ""  )

static

Returns the number of items of the specified class that are bound to the specified source object.

Parameters

DataItem	$source	the source item
string	$class	the class of bound items to retrieve
string	$constraint	optional extra constraint or ordering

Returns

array any items of the specified class that are bound to the target

Definition at line 597 of file taxonomy_manager.inc.

     {
          $constraint = preg_replace("/^\\s*WHERE/i", "AND", $constraint);
          $obj = new $class;
          $pk = $obj->getPrimaryKey();
          
          $items = Query::create($class, "WHERE $pk IN (SELECT target_id FROM binding WHERE id=:source_id and class=:source_class AND target_class=:target_class) $constraint")
                           ->bind(":source_id", $source->get($source->getPrimaryKey()),
                                    ":target_class", $class,
                                    ":source_class", get_class($source))
                           ->executeValue("COUNT(1)");
           
          return $items;
     }

countBoundItemsReverse()

static TaxonomyManager::countBoundItemsReverse (   $target,   $class,   $constraint = ""  )

static

Same as TaxonomyManager::countBoundItems, but with the reverse relationship.

Parameters

DataItem	$target	the target item
string	$class	the class of bound items to retrieve
string	$constraint	optional extra constraint or ordering

Returns

array any items of the specified class that are bound to the target

Definition at line 619 of file taxonomy_manager.inc.

     {
          $constraint = preg_replace("/^\\s*WHERE/i", "AND", $constraint);
          $obj = new $class;
          $pk = $obj->getPrimaryKey();
     
          $items = Query::create($class, "WHERE $pk IN (SELECT id FROM binding WHERE target_id=:target_id and class=:source_class AND target_class=:target_class) $constraint")
          ->bind(":target_id", $target->get($target->getPrimaryKey()),
                    ":target_class", get_class($target),
                    ":source_class", $class)
                    ->executeValue("COUNT(1)");
               
          return $items;
     
     }

generateSearchConstraint()

static TaxonomyManager::generateSearchConstraint (   $text,   $class,   $placeholder = false  )

static

Generates a search constraint matching the supplied text against taxonomy terms that might be associated with the given class.

Parameters

string	$text	the search text
string	$class	the DataItem class that is being search
string	$placeholder	true if $text is a placeholder variable, false,

Returns

string a SQL constraint that can be used to perform the taxonomy text match

Definition at line 643 of file taxonomy_manager.inc.

     {         
          $obj = new $class;
          $pk = $obj->getPrimaryKey();
          $text = $placeholder ? $text : "'$text'";
          
          return "$pk in (select id from taxonomy_term_association a, taxonomy_term t where t.term like {$text} and a.term_id=t.term_id and a.class='{$class}')";
     }

getAssociatedTaxonomies()

static TaxonomyManager::getAssociatedTaxonomies (   $classes,   $facet_filter_only = false  )

static

Definition at line 298 of file taxonomy_manager.inc.

     {
          if (!is_array($classes))
          {
               $classes = array($classes);
          }
          
          $matched = array();
          
          $taxonomies = Query::create(Taxonomy, "")->execute();
          
          foreach($taxonomies as $taxonomy)
          {
               if ($facet_filter_only and !$taxonomy->enable_facet_filter) continue;
               
               $taxonomy_classes = explode(",", $taxonomy->associated_classes);
               foreach($classes as $class)
               {
                    if (array_search($class, $taxonomy_classes) !== FALSE)
                    {
                         $matched[] = $taxonomy;
                         break;
                    }
               }
          }    
          
          return $matched;    
     }

getBindableClasses()

static TaxonomyManager::getBindableClasses ( )

static

Definition at line 150 of file taxonomy_manager.inc.

     {
          if (!TaxonomyManager::$bindableClasses)
          {
               $bindableClasses = array();
               ComponentManager::fireEvent("RegisterBindableClasses");
          }
          
          return TaxonomyManager::$bindableClasses;
     }

getBindableClassOptions()

static TaxonomyManager::getBindableClassOptions ( )

static

Definition at line 167 of file taxonomy_manager.inc.

     {
          $classes = TaxonomyManager::getBindableClasses();
     
          $options = array();
     
          foreach($classes as $class => $format)
          {
               $proto = new $class;
               $options[$class] = $proto->prettifyClassName();
          }
     
          return $options;
     }

getBindingFacetFilterClass()

static TaxonomyManager::getBindingFacetFilterClass (   $bindingTarget )

static

Definition at line 211 of file taxonomy_manager.inc.

     {
          $classes = TaxonomyManager::getBindableClasses();
          return $classes[$bindingTarget->target_class]["facet_filter"];
     }

getBindingFieldRendererClass()

static TaxonomyManager::getBindingFieldRendererClass (   $bindingTarget )

static

Definition at line 205 of file taxonomy_manager.inc.

     {
          $classes = TaxonomyManager::getBindableClasses();
          return $classes[$bindingTarget->target_class]["field_renderer"];
     }

getBindingOptionFormat()

static TaxonomyManager::getBindingOptionFormat (   $bindingTarget )

static

Definition at line 199 of file taxonomy_manager.inc.

     {
          $classes = TaxonomyManager::getBindableClasses();
          return $classes[$bindingTarget->target_class]["format"];
     }

getBindingOptions()

static TaxonomyManager::getBindingOptions (   $bindingTarget )

static

Definition at line 182 of file taxonomy_manager.inc.

     {
          TaxonomyManager::getBindableClasses();
          
          $class = is_object($bindingTarget) ? get_class($bindingTarget) : $bindingTarget;
          $bindingDetails = TaxonomyManager::$bindableClasses[$class];
          if (!$bindingDetails) 
          {
               trace("## $class is not registered as a binding target", 1);
               return array();
          }
          
          $targets = Query::create($class, $bindingDetails["constraint"])->execute();
          
          return $targets;
     }

getBindingTargets()

static TaxonomyManager::getBindingTargets (   $classes,   $facet_filter_only = false  )

static

Definition at line 327 of file taxonomy_manager.inc.

     {
          if (!is_array($classes))
          {
               $classes = array($classes);
          }
          
          $matched = array();
          
          $bindingTargets = Query::create(BindingTarget, "")->execute();
          
          foreach($bindingTargets as $bindingTarget)
          {
               if ($facet_filter_only and !$bindingTarget->enable_facet_filter) continue;
               
               $assoc_classes = explode(",", $bindingTarget->associated_classes);
               foreach($classes as $class)
               {
                    if (array_search($class, $assoc_classes) !== FALSE)
                    {
                         $matched[] = $bindingTarget;
                         break;
                    }
               }
          }    
          
          return $matched;    
     }

getBoundItems()

static TaxonomyManager::getBoundItems (   $source,   $class,   $constraint = ""  )

static

Retrieve items of the specified class that are bound to the specified source object.

Parameters

DataItem	$source	the source item
string	$class	the class of bound items to retrieve
string	$constraint	optional extra constraint or ordering

Returns

array any items of the specified class that are bound to the target

Definition at line 552 of file taxonomy_manager.inc.

     {
          $constraint = preg_replace("/^\\s*WHERE/i", "AND", $constraint);
          $obj = new $class;
          $pk = $obj->getPrimaryKey();
          
          $items = Query::create($class, "WHERE $pk IN (SELECT target_id FROM binding WHERE id=:source_id and class=:source_class AND target_class=:target_class) $constraint")
                           ->bind(":source_id", $source->get($source->getPrimaryKey()),
                                    ":target_class", $class,
                                    ":source_class", get_class($source))
                           ->execute();
           
          return $items;
     }

getBoundItemsReverse()

static TaxonomyManager::getBoundItemsReverse (   $target,   $class,   $constraint = ""  )

static

Same as TaxonomyManager::getBoundItems, but with the reverse relationship.

Parameters

DataItem	$target	the target item
string	$class	the class of bound items to retrieve
string	$constraint	optional extra constraint or ordering

Returns

array any items of the specified class that are bound to the target

Definition at line 574 of file taxonomy_manager.inc.

     {
          $constraint = preg_replace("/^\\s*WHERE/i", "AND", $constraint);
          $obj = new $class;
          $pk = $obj->getPrimaryKey();
          
          $items = Query::create($class, "WHERE $pk IN (SELECT id FROM binding WHERE target_id=:target_id and class=:source_class AND target_class=:target_class) $constraint")
          ->bind(":target_id", $target->get($target->getPrimaryKey()),
                    ":target_class", get_class($target),
                    ":source_class", $class)
                    ->execute();
               
          return $items;
          
     }

getRegisteredClasses()

static TaxonomyManager::getRegisteredClasses ( )

static

Retrieved the list of DataItem classes that have registered as supporting taxonomy term associations.

Returns

array of class names

Definition at line 121 of file taxonomy_manager.inc.

     {
          $registeredClasses = array();
          
          $registeredClasses = ComponentManager::fireEvent("RegisterTaxonomyClasses", $registeredClasses);
          
          return $registeredClasses;
     }

getRegisteredClassOptions()

static TaxonomyManager::getRegisteredClassOptions ( )

static

Retrieves the list of DataItem classes that have registered as supporting taxonomy term associations in an associated array format suitable for use with a SelectFieldRenderer or CheckListFieldRenderer.

Returns

array

Definition at line 135 of file taxonomy_manager.inc.

     {
          $classes = TaxonomyManager::getRegisteredClasses();
          
          $options = array();
          
          foreach($classes as $class)
          {
               $proto = new $class;
               $options[$class] = $proto->prettifyClassName(true);
          }
          
          return $options;
     }

getRequestFilterConstraint()

static TaxonomyManager::getRequestFilterConstraint (   $class )

static

Definition at line 471 of file taxonomy_manager.inc.

     {
          $taxonomies = TaxonomyManager::getAssociatedTaxonomies($class, true);
          
          $obj = new $class;
          $pk = $obj->getPrimaryKey();
          
          $clauses = array();
          
          foreach($taxonomies as $taxonomy)
          {
               if (isset($_REQUEST[$taxonomy->identifier]))
               {
                    $term_ids = $_REQUEST[$taxonomy->identifier];
                    
                    if (!$term_ids) continue;
                    if (!preg_match("/^[\\d,]+/", $term_ids))
                    {
                         throw new FakoliException("Invalid facet filter terms");
                    }
                    
                    $clauses[] = "$pk IN (SELECT id FROM taxonomy_term_association WHERE class='$class' AND term_id IN ($term_ids))";
               }
          }
          
          return implode(" AND ", $clauses);
     }

getRequestTerms()

static TaxonomyManager::getRequestTerms (   $classes )

static

Definition at line 445 of file taxonomy_manager.inc.

     {
          $ids = array();
          
          if (!is_array($classes) && $classes) $classes = array($classes);
          
          $taxonomies = TaxonomyManager::getAssociatedTaxonomies($classes, true);
          foreach($taxonomies as $taxonomy)
          {
               if (isset($_REQUEST[$taxonomy->identifier]))
               {
                    $term_ids = explode(",", $_REQUEST[$taxonomy->identifier]);
                    checkNumeric($term_ids);
                    foreach($term_ids as $term_id)
                    {
                         if ($term_id) $ids[] = $term_id;
                    }
               }
          }
 
          if (count($ids) == 0) return array();
          $idString = implode(", ", $ids);
          
          return Query::create(TaxonomyTerm, "WHERE term_id IN ($idString)")->execute();
     }

getTabs()

static TaxonomyManager::getTabs (   $key )

static

Definition at line 108 of file taxonomy_manager.inc.

     {
          $tabs = array( "Taxonomy Definition"    =>   "/admin/taxonomy_form",
                              "Terms"                       =>   "/admin/taxonomy_terms");
          
          $qs = ($key) ? "taxonomy_id=$key" : ""; 
          return new TabBar("tabs", $tabs, $qs);
     }

importTerms()

static TaxonomyManager::importTerms (   $taxonomy,   $file  )

static

Definition at line 356 of file taxonomy_manager.inc.

     {
          $indexedTerms = reindexList($taxonomy->Terms(), "term");
          
          $fp = fopen($file, "r");
          
          $fields = fgetcsv($fp);
          
          $fileIdx = -1;
          
          foreach($fields as $field)
          {
               if ($field == "term")
               {
                    $fileIdx = $i;
                    break;
               }
               
               $i++;
          }
 
          if ($fileIdx < 0)
          {
               throw new FakoliException("'term' column not present");
          }
          
          while($values = fgetcsv($fp))
          {
               $term = $values[$fileIdx];
               
               trace("Importing term", 3);
               
               $i = 0;
                         
               if (array_key_exists($term, $indexedTerms)) 
               {
                    $import = $indexedTerms[$term];
                    foreach($fields as $field)
                    {                        
                         $import->set($field, $values[$i]);
                         $i++;
                    }
                         
                    $import->save();
               }
               else
               {
                    $import = new TaxonomyTerm();
                    foreach($fields as $field)
                    {                        
                         $import->set($field, $values[$i]);
                         $i++;
                    }
               
                    $import->taxonomy_id = $taxonomy->taxonomy_id;
                    $import->save();
               }
          }
          
          fclose($fp);
     }

registerBindableClass()

static TaxonomyManager::registerBindableClass (   $class,   $format,   $constraint = "",   $fieldRenderer = BindingTargetFieldRenderer,   $facetFilter = BindingTargetFacetFilter  )

static

Definition at line 161 of file taxonomy_manager.inc.

     {
          TaxonomyManager::$bindableClasses[$class] = array("format" => $format, "constraint" => $constraint, 
                                                                        "field_renderer" => $fieldRenderer, "facet_filter" => $facetFilter);
     }

registerSerializationHandler()

static TaxonomyManager::registerSerializationHandler ( )

static

Definition at line 658 of file taxonomy_manager.inc.

     {
          SerializationManager::registerHandler("taxonomy", "Taxonomies and Terms", new TaxonomySerializationHandler());
          SerializationManager::registerHandler("taxonomy_associations", "Taxonomy Term Associations", new SimpleSerializationHandler(TaxonomyTermAssociation));
          return true;
     }

setDefaults()

static TaxonomyManager::setDefaults ( )

static

Definition at line 103 of file taxonomy_manager.inc.

     {
          //TODO: Set default configuration parameters here
     }

upgradeComponent()

static TaxonomyManager::upgradeComponent (   $version )

static

Definition at line 652 of file taxonomy_manager.inc.

     {
          $mgr = new TaxonomyUpgradeManager();
          $mgr->upgrade($version);
     }    

Member Data Documentation

$bindableClasses

TaxonomyManager::$bindableClasses = null

static

Definition at line 92 of file taxonomy_manager.inc.

---

The documentation for this class was generated from the following file:

• C:/code/cms.sonjara.com/cms/components/taxonomy/taxonomy_manager.inc