/**
  * Load the next bunch of items
  * 
  * @return void
  * @access public
  * @since 3/1/06
  */
 function loadNext()
 {
     $dbc = Services::getService("DatabaseManager");
     // get the list of the next set of Ids
     $query = new SelectQuery();
     $query->addTable("log_entry");
     $query->addColumn("id", "entry_id", "log_entry");
     $query->setDistinct(true);
     $query->addOrderBy("timestamp", DESCENDING);
     $this->addWhereClauses($query);
     $query->limitNumberOfRows($this->_numPerLoad);
     if ($this->_currentRow) {
         $query->startFromRow($this->_currentRow + 1);
     }
     // 		printpre('CurrentRow at load: '.$this->_currentRow);
     // 		printpre($query->asString());
     $results = $dbc->query($query, $this->_dbIndex);
     $nextIds = array();
     while ($results->hasNext()) {
         $row = $results->next();
         $nextIds[] = $row['entry_id'];
     }
     // 		printpre($nextIds);
     /*********************************************************
      * Load the rows for the next set of Ids
      *********************************************************/
     $query = new SelectQuery();
     $query->addTable("log_entry");
     $query->addColumn("id", "id", "log_entry");
     $query->addColumn("timestamp", "timestamp", "log_entry");
     $query->addColumn("category", "category", "log_entry");
     $query->addColumn("description", "description", "log_entry");
     $query->addColumn("backtrace", "backtrace", "log_entry");
     $subQuery = new SelectQuery();
     $subQuery->addColumn("*");
     $subQuery->addTable("log_agent");
     $subQuery->addWhereIn("fk_entry", $nextIds);
     $query->addDerivedTable($subQuery, LEFT_JOIN, "log_entry.id = tmp_agent.fk_entry", "tmp_agent");
     $query->addColumn("fk_agent", "agent_id", "tmp_agent");
     $subQuery = new SelectQuery();
     $subQuery->addColumn("*");
     $subQuery->addTable("log_node");
     $subQuery->addWhereIn("fk_entry", $nextIds);
     $query->addDerivedTable($subQuery, LEFT_JOIN, "log_entry.id = tmp_node.fk_entry", "tmp_node");
     $query->addColumn("fk_node", "node_id", "tmp_node");
     $query->addWhereIn("id", $nextIds);
     $query->addOrderBy("timestamp", DESCENDING);
     $query->addOrderBy("id", ASCENDING);
     //  		printpre($query->asString());
     $results = $dbc->query($query, $this->_dbIndex);
     $i = $this->_current;
     $currentEntryId = null;
     $timestamp = null;
     $category = null;
     $description = null;
     $backtrace = '';
     $agents = array();
     $nodes = array();
     while ($results->hasNext()) {
         $row = $results->next();
         // Create the entry if we have all of the data for it.
         if ($currentEntryId && $currentEntryId != $row["id"]) {
             // 				printpre("Creating Entry: ".$currentEntryId." ".$timestamp." -- ".($i+1)." of ".$this->_count);
             $this->_entries[$i] = new HarmoniEntry($dbc->fromDBDate($timestamp, $this->_dbIndex), $category, $description, $backtrace, array_unique($agents), array_unique($nodes), $this->_formatType, $this->_priorityType);
             $i++;
             $this->_currentRow++;
             $currentEntryId = null;
             $timestamp = null;
             $category = null;
             $description = null;
             $backtrace = '';
             $agents = array();
             $nodes = array();
         }
         $currentEntryId = $row["id"];
         $timestamp = $row["timestamp"];
         $category = $row["category"];
         $description = $row["description"];
         $backtrace = $row["backtrace"];
         $agents[] = $row["agent_id"];
         $nodes[] = $row["node_id"];
         // 			printpre($currentEntryId." ".$timestamp." ".$this->_currentRow);
     }
     $results->free();
     // get the last entry if we are at the end of the iterator
     if ($currentEntryId && $i == $this->_count - 1) {
         // 			printpre("Creating Entry: ".$currentEntryId." ".$timestamp." -- ".($i+1)." of ".$this->_count);
         $this->_entries[$i] = new HarmoniEntry($dbc->fromDBDate($timestamp, $this->_dbIndex), $category, $description, $backtrace, array_unique($agents), array_unique($nodes), $this->_formatType, $this->_priorityType);
     }
 }
Ejemplo n.º 2
0
 /**
  * Load authorizations for multiple qualifiers
  * 
  * @param string $agentIdString
  * @param array $qualifierIdStrings
  * @return void
  * @access public
  * @since 4/29/08
  */
 public function _loadMultiple($agentIdString, array $qualifierIdStrings)
 {
     $dbHandler = Services::getService("DatabaseManager");
     $dbIndex = $this->_configuration->getProperty('database_index');
     $agentIdStrings = $this->getAgentIdStringArray($agentIdString);
     /*********************************************************
      * Explicit AZs
      *********************************************************/
     // Select and create all of the explicit AZs
     $query = new SelectQuery();
     $query->addColumn("*");
     $query->addTable("az2_explicit_az");
     $query->addWhereIn("fk_agent", $agentIdStrings);
     $query->addWhere("(effective_date IS NULL OR effective_date < NOW())");
     $query->addWhere("(expiration_date IS NULL OR expiration_date > NOW())");
     $query->addWhereIn("fk_qualifier", $qualifierIdStrings);
     // 		printpre(MySQL_SQLGenerator::generateSQLQuery($query));
     $result = $dbHandler->query($query, $dbIndex);
     // Create the explicit AZs
     while ($result->hasMoreRows()) {
         // Set a boolean for the AZ.
         if (!isset($_SESSION['__isAuthorizedCache'][$agentIdString][$result->field("fk_qualifier")])) {
             $_SESSION['__isAuthorizedCache'][$agentIdString][$result->field("fk_qualifier")] = array();
         }
         $_SESSION['__isAuthorizedCache'][$agentIdString][$result->field("fk_qualifier")][$result->field("fk_function")] = true;
         $result->advanceRow();
     }
     $result->free();
     /*********************************************************
      * Implicit AZs	
      *********************************************************/
     // Select and create all of the explicit AZs
     $query = new SelectQuery();
     $query->addColumn("*");
     $query->addTable("az2_implicit_az");
     $query->addWhereIn("fk_agent", $agentIdStrings);
     $query->addWhere("(effective_date IS NULL OR effective_date < NOW())");
     $query->addWhere("(expiration_date IS NULL OR expiration_date > NOW())");
     $query->addWhereIn("fk_qualifier", $qualifierIdStrings);
     // 		printpre(MySQL_SQLGenerator::generateSQLQuery($query));
     $result = $dbHandler->query($query, $dbIndex);
     // Create the explicit AZs
     while ($result->hasMoreRows()) {
         // Set a boolean for the AZ.
         if (!isset($_SESSION['__isAuthorizedCache'][$agentIdString][$result->field("fk_qualifier")])) {
             $_SESSION['__isAuthorizedCache'][$agentIdString][$result->field("fk_qualifier")] = array();
         }
         $_SESSION['__isAuthorizedCache'][$agentIdString][$result->field("fk_qualifier")][$result->field("fk_function")] = true;
         $result->advanceRow();
     }
     $result->free();
 }
 /**
  * Answer the Hierarchy-based parent-group for an external group Id.
  * 
  * @param array $groupIds An array of Ids
  * @return array an array of parent group Ids
  * @access public
  * @since 11/6/07
  */
 public function getHierarchyParentIdsForExternalGroups(array $groupIds)
 {
     if (!count($groupIds)) {
         return array();
     }
     $query = new SelectQuery();
     $query->addTable('agent_external_children');
     $query->addColumn('DISTINCT fk_parent', 'parent');
     // Before PHP 5.2.0, __toString() was only called automatically
     // in print() statements, not in concatinations.
     if (version_compare(phpversion(), '5.2.0', '<')) {
         foreach ($groupIds as $key => $val) {
             if (is_object($val)) {
                 $groupIds[$key] = $val->__toString();
             }
         }
     }
     $query->addWhereIn('fk_child', $groupIds);
     $dbc = Services::getService("DBHandler");
     $result = $dbc->query($query, $this->_configuration->getProperty('database_index'));
     $idMgr = Services::getService("Id");
     $parents = array();
     while ($result->hasMoreRows()) {
         $parents[] = $idMgr->getId($result->field('parent'));
         $result->advanceRow();
     }
     return $parents;
 }
Ejemplo n.º 4
0
 /**
  * Answer the internal slot definitions for the shortnames passed
  * 
  * @param array $shortnames An array of strings
  * @return array
  * @access private
  * @since 1/4/08
  */
 private function getInternalSlotDefinitionsForShortnames(array $shortnames)
 {
     if (!count($shortnames)) {
         return array();
     }
     $query = new SelectQuery();
     $query->addTable('segue_slot');
     $query->addTable('segue_slot_owner AS all_owners', LEFT_JOIN, 'segue_slot.shortname = all_owners.shortname');
     $query->addColumn('segue_slot.shortname', 'shortname');
     $query->addColumn('segue_slot.site_id', 'site_id');
     $query->addColumn('segue_slot.alias_target', 'alias_target');
     $query->addColumn('segue_slot.type', 'type');
     $query->addColumn('segue_slot.location_category', 'location_category');
     $query->addColumn('segue_slot.media_quota', 'media_quota');
     $query->addColumn('all_owners.owner_id', 'owner_id');
     $query->addColumn('all_owners.removed', 'removed');
     $query->addWhereIn('segue_slot.shortname', $shortnames);
     // 		printpre($query->asString());
     $dbc = Services::getService('DBHandler');
     $result = $dbc->query($query, IMPORTER_CONNECTION);
     return $this->getSlotsFromQueryResult($result);
 }
Ejemplo n.º 5
0
 /**
  * Load all of the Authorizations for the user and cache them
  * 
  * @return void
  * @access public
  * @since 11/10/05
  */
 function _loadQueue($agentIdString)
 {
     if (!count($this->_queue[$agentIdString])) {
         return;
     }
     $dbHandler = Services::getService("DatabaseManager");
     $dbIndex = $this->_configuration->getProperty('database_index');
     $idManager = Services::getService("Id");
     $functions = array();
     //used by Algorithm A
     // 		$timer = new Timer;
     // 		$timer->start();
     // 		$startingQueries = $dbHandler->getTotalNumberOfQueries();
     // Explicit AZs
     // Select and create all of the explicit AZs
     $query = new SelectQuery();
     $query->addColumn("*");
     $query->addTable("az_authorization");
     $agentIdStrings = $this->getAgentIdStringArray($agentIdString);
     foreach ($agentIdStrings as $key => $val) {
         $agentIdStrings[$key] = "'" . addslashes($val) . "'";
     }
     $query->addWhere("fk_agent IN(" . implode(", ", $agentIdStrings) . ")");
     $query->addWhere("(authorization_effective_date IS NULL OR authorization_effective_date < NOW())");
     $query->addWhere("(authorization_expiration_date IS NULL OR authorization_expiration_date > NOW())");
     // 		printpre(MySQL_SQLGenerator::generateSQLQuery($query));
     $result = $dbHandler->query($query, $dbIndex);
     // Create the explicit AZs
     while ($result->hasMoreRows()) {
         $az = new HarmoniAuthorization($result->field("authorization_id"), $idManager->getId($result->field("fk_agent")), $idManager->getId($result->field("fk_function")), $idManager->getId($result->field("fk_qualifier")), true, $this->_authorizationManagerObjectCache, $dbHandler->fromDBDate($result->field("authorization_effective_date"), $dbIndex), $dbHandler->fromDBDate($result->field("authorization_expiration_date"), $dbIndex));
         // cache in our explictAZ cache for referencing by implicit AZs
         $explicitAZs[$result->field("authorization_id")] = $az;
         // Build a list of functions for AlogrithmA to use when setting implicitAZs
         $functions[] = $result->field("fk_function");
         // Set a boolean for the AZ.
         if (!isset($_SESSION['__isAuthorizedCache'][$agentIdString][$result->field("fk_qualifier")])) {
             $_SESSION['__isAuthorizedCache'][$agentIdString][$result->field("fk_qualifier")] = array();
         }
         $_SESSION['__isAuthorizedCache'][$agentIdString][$result->field("fk_qualifier")][$result->field("fk_function")] = true;
         $result->advanceRow();
     }
     $result->free();
     /*********************************************************
      * Implicit AZs	
      *********************************************************/
     // Algorithm A:
     // For this algorithm we will do a single traversal of the hierarchy
     // and set implicit authorization bits on the way down as we pass
     // explicit AZs.
     // 		$hierarchyManager = Services::getService("Hierarchy");
     // 		$hierarchies =$hierarchyManager->getHierarchies();
     // 		while ($hierarchies->hasNext()) {
     // 			$hierarchy =$hierarchies->next();
     // 			$rootNodes =$hierarchy->getRootNodes();
     // 			while ($rootNodes->hasNext()) {
     // 				$rootNode =$rootNodes->next();
     //
     // 				$rootNodeId =$rootNode->getId();
     // // 				print "\n<h1>Traversing from RootNode: ".$rootNodeId->getIdString()."</h1>";
     //
     // 				$timer2 = new Timer;
     // 				$timer2->start();
     // 				$traversal =$hierarchy->traverse(
     // 					$rootNode->getId(),
     // 					Hierarchy::TRAVERSE_MODE_DEPTH_FIRST,
     // 					Hierarchy::TRAVERSE_DIRECTION_DOWN,
     // 					Hierarchy::TRAVERSE_LEVELS_ALL);
     // 				$timer2->end();
     // 				printf("<br/>CacheAZ Traversal Time: %1.6f", $timer2->printTime());
     //
     // 				$explicitAZLevels = array();
     //
     // 				while ($traversal->hasNext()) {
     // 					$info =$traversal->next();
     // 					$id =$info->getNodeId();
     // 					$idString = $id->getIdString();
     // 					$level = $info->getLevel();
     // // 					printpre("<strong>$level\t$idString</strong>");
     //
     // 					foreach($functions as $functionId) {
     // 						if (!isset($explicitAZLevels[$functionId])) {
     // 							if (isset($_SESSION['__isAuthorizedCache'][$agentIdString][$idString][$functionId])) {
     // 								$explicitAZLevels[$functionId] = $level;
     // // 								printpre("\tFound Explicit $functionId at level $level");
     // 							}
     // 						} else {
     // 							if ($level <= $explicitAZLevels[$functionId]) {
     // 								unset($explicitAZLevels[$functionId]);
     // // 								printpre("\tUnsetting ExplicitAZ $functionId at $level");
     // 							} else {
     // 								$_SESSION['__isAuthorizedCache'][$agentIdString][$idString][$functionId] = true;
     // // 								printpre("\tSetting Implicit $functionId at level $level");
     // 							}
     // 						}
     // 					}
     // 				}
     // 			}
     // 		}
     // Before we do the big work to find the implicit AZs, first check that the
     // node Ids we are looking for exist. If not, make note of this and do not search
     // for them.
     $query = new SelectQuery();
     $query->addColumn("DISTINCT node_id");
     $query->addTable("node");
     $query->addWhereIn("node_id", $this->_queue[$agentIdString]);
     $result = $dbHandler->query($query, $this->_configuration->getProperty('database_index'));
     $foundNodes = array();
     while ($result->hasMoreRows()) {
         $foundNodes[] = $result->field('node_id');
         $result->advanceRow();
     }
     $result->free();
     // Get a list of missing nodes
     $missing = array_diff($this->_queue[$agentIdString], $foundNodes);
     foreach ($missing as $nodeId) {
         $_SESSION['__isAuthorizedCacheUnknownIds'][] = $nodeId;
     }
     // Algorithm B:
     // For this algorithm we want to join all of the explicit AZs to all
     // nodes who have the qulifier as an ancestor. These will be the implicit AZs
     if (count($foundNodes)) {
         $query = new SelectQuery();
         $query->addColumn("authorization_id");
         $query->addColumn("fk_node");
         $query->addTable("az_authorization");
         $query->addTable("node_ancestry", LEFT_JOIN, "fk_qualifier = fk_ancestor");
         $query->addWhereIn("fk_node", $foundNodes);
         $agentIdStrings = $this->getAgentIdStringArray($agentIdString);
         foreach ($agentIdStrings as $key => $val) {
             $agentIdStrings[$key] = "'" . addslashes($val) . "'";
         }
         $query->addWhere("fk_agent IN(" . implode(", ", $agentIdStrings) . ")");
         $query->addWhere("(authorization_effective_date IS NULL OR authorization_effective_date < NOW())");
         $query->addWhere("(authorization_expiration_date IS NULL OR authorization_expiration_date > NOW())");
         // 		printpre(MySQL_SQLGenerator::generateSQLQuery($query));
         $result = $dbHandler->query($query, $this->_configuration->getProperty('database_index'));
         while ($result->hasMoreRows()) {
             $explicitAZ = $explicitAZs[$result->field("authorization_id")];
             $explicitFunction = $explicitAZ->getFunction();
             $explicitFunctionId = $explicitFunction->getId();
             // cache in our user AZ cache
             if (!isset($_SESSION['__isAuthorizedCache'][$agentIdString][$result->field("fk_node")])) {
                 $_SESSION['__isAuthorizedCache'][$agentIdString][$result->field("fk_node")] = array();
             }
             $_SESSION['__isAuthorizedCache'][$agentIdString][$result->field("fk_node")][$explicitFunctionId->getIdString()] = true;
             $result->advanceRow();
         }
         $result->free();
         // Set flags that each Qualifier in the queue has had its implicit AZs cached.
         foreach ($this->_queue[$agentIdString] as $qualifierIdString) {
             $_SESSION['__isAuthorizedCache'][$agentIdString][$qualifierIdString]['__IMPLICIT_CACHED'] = true;
         }
     }
     // 		$timer->end();
     // 		printf("<br/>CacheAZTime: %1.6f", $timer->printTime());
     // 		print "<br/>Num Queries: ".($dbHandler->getTotalNumberOfQueries() - $startingQueries);
     $this->_queue[$agentIdString] = array();
     // 		@$this->ticker++;
     // 		if ($this->ticker > 100) {
     // 			printpre($_SESSION['__isAuthorizedCache'][$agentIdString]);
     // 			exit;
     // 		}
 }
 /**
  * Auxilliary private function that returns Authorizations according to a
  * criteria. Null values are interpreted as wildmarks. Warning: $returnExplicitOnly = false
  * will increase the running time significantly - USE SPARINGLY!
  * @access public
  * @param string aId The string id of an agent.
  * @param string fId The string id of a function.
  * @param string qId The string id of a qualifier. This parameter can not be null
  * and used as a wildmark.
  * @param object fType The type of a function.
  * @param boolean returnExplicitOnly If True, only explicit Authorizations
  *		will be returned.
  * @param boolean searchUp If true, the ancester nodes of the qualifier will
  *		be checked as well
  * @param boolean isActiveNow If True, only active Authorizations will be returned.
  * @return ref object An AuthorizationIterator.
  **/
 function getAZs($aId, $fId, $qId, $fType, $returnExplicitOnly, $searchUp, $isActiveNow, $groupIds = array())
 {
     // 		printpre (func_get_args());
     // ** parameter validation
     $rule = StringValidatorRule::getRule();
     ArgumentValidator::validate($groupIds, ArrayValidatorRuleWithRule::getRule(OptionalRule::getRule($rule)), true);
     ArgumentValidator::validate($aId, OptionalRule::getRule($rule), true);
     ArgumentValidator::validate($fId, OptionalRule::getRule($rule), true);
     ArgumentValidator::validate($qId, OptionalRule::getRule($rule), true);
     ArgumentValidator::validate($fType, OptionalRule::getRule(ExtendsValidatorRule::getRule("Type")), true);
     ArgumentValidator::validate($returnExplicitOnly, BooleanValidatorRule::getRule(), true);
     ArgumentValidator::validate($isActiveNow, BooleanValidatorRule::getRule(), true);
     // ** end of parameter validation
     $idManager = Services::getService("Id");
     // the parameter that influences the result most is $returnExplicitOnly
     // 1) If $returnExplicitOnly is TRUE, then we only need to check for Authorizations
     // that have been explicitly created, i.e. no need to look for inherited
     // authorizations
     // 2) If $returnExplicitOnly is FALSE, then we need to include inherited Authorizations
     // as well.
     // this array will store the ids of all qualifiers to be checked for authorizations
     $qualifiers = array();
     // check all ancestors of given qualifier
     $hierarchyManager = Services::getService("Hierarchy");
     if (isset($qId)) {
         $qualifierId = $idManager->getId($qId);
         $node = $hierarchyManager->getNode($qualifierId);
         $hierarchy = $hierarchyManager->getHierarchyForNode($node);
         if ($searchUp) {
             // these are the ancestor nodes
             $nodes = $hierarchy->traverse($qualifierId, Hierarchy::TRAVERSE_MODE_DEPTH_FIRST, Hierarchy::TRAVERSE_DIRECTION_UP, Hierarchy::TRAVERSE_LEVELS_ALL);
             // now get the id of each node and store in array
             while ($nodes->hasNext()) {
                 $info = $nodes->next();
                 $id = $info->getNodeId();
                 $qualifiers[] = $id->getIdString();
             }
         } else {
             $qualifiers = array($qId);
         }
     }
     //		print_r($qualifiers);
     // setup the query
     $dbHandler = Services::getService("DatabaseManager");
     $query = new SelectQuery();
     $query->addColumn("authorization_id", "id");
     $query->addColumn("fk_agent", "aid");
     $query->addColumn("fk_function", "fid");
     $query->addColumn("fk_qualifier", "qid");
     $query->addColumn("authorization_effective_date", "eff_date");
     $query->addColumn("authorization_expiration_date", "exp_date");
     $query->addTable("az_authorization");
     // now include criteria
     // the qualifiers criteria
     if (isset($qualifiers) && count($qualifiers)) {
         $query->addWhereIn('az_authorization.fk_qualifier', $qualifiers);
     }
     // Agents/Groups
     if (isset($aId)) {
         $agentIds = array($aId);
     } else {
         $agentIds = array();
     }
     $allAgentIds = array_merge($agentIds, $groupIds);
     // the agent criteria
     if (count($allAgentIds)) {
         $query->addWhereIn('az_authorization.fk_agent', $allAgentIds);
     }
     // the function criteria
     if (isset($fId)) {
         $joinc = "az_authorization.fk_function = az_function.function_id";
         $query->addTable("az_function", INNER_JOIN, $joinc);
         $query->addWhereEqual("az_authorization.fk_function", $fId);
     }
     // the function type criteria
     if (isset($fType)) {
         // do not join with az_function if we did already
         if (!isset($fId)) {
             $joinc = "az_authorization.fk_function = az_function.function_id";
             $query->addTable("az_function", INNER_JOIN, $joinc);
         }
         // now join with type
         $joinc = "az_function.fk_type = type.type_id";
         $query->addTable("type", INNER_JOIN, $joinc);
         $query->addWhereEqual("type.type_domain", $fType->getDomain());
         $query->addWhereEqual("type.type_authority", $fType->getAuthority());
         $query->addWhereEqual("type.type_keyword", $fType->getKeyword());
     }
     // the isActiveNow criteria
     if ($isActiveNow) {
         $where = "(authorization_effective_date IS NULL OR (NOW() >= authorization_effective_date))";
         $query->addWhere($where);
         $where = "(authorization_expiration_date IS NULL OR (NOW() < authorization_expiration_date))";
         $query->addWhere($where);
     }
     $query->addOrderBy("authorization_id");
     //		echo "<pre>\n";
     //		echo MySQL_SQLGenerator::generateSQLQuery($query);
     //		echo "</pre>\n";
     $queryResult = $dbHandler->query($query, $this->_dbIndex);
     // this array will store the authorizations that will be returned
     $authorizations = array();
     // we only want to create one implicitAZ for a given Agent/Function/Qualifier
     // combo, so maintain a list of already created ones to skip
     $createdImplicitAZs = array();
     $i = 0;
     // process all rows and create the explicit authorizations
     while ($queryResult->hasMoreRows()) {
         $row = $queryResult->getCurrentRow();
         // 			printpre($row);
         $idValue = $row['id'];
         $id = $idManager->getId($idValue);
         if (isset($this->_authorizations[$idValue])) {
             $authorization = $this->_authorizations[$idValue];
         } else {
             $agentId = $idManager->getId($row['aid']);
             $functionId = $idManager->getId($row['fid']);
             $explicitQualifierId = $idManager->getId($row['qid']);
             $effectiveDate = $dbHandler->fromDBDate($row['eff_date'], $this->_dbIndex);
             $expirationDate = $dbHandler->fromDBDate($row['exp_date'], $this->_dbIndex);
             // create the explicit authorization (each explicit authorization
             // has a corresponding row in the authorization db table)
             $authorization = new HarmoniAuthorization($idValue, $agentId, $functionId, $explicitQualifierId, true, $this, $effectiveDate, $expirationDate);
             $this->_authorizations[$idValue] = $authorization;
         }
         // Explicit AZ for ancestor qualifiers and groups should have
         // corresponding implicit AZs
         // in decendents, but not appear in their AZs directly.
         // Therefore, only add the explicit AZ if it is for the requested
         // qualifier and agent if we are fetching more than just the explicitAZs.
         if ($row['qid'] == $qId && $row['aid'] == $aId || $returnExplicitOnly) {
             $authorizations[] = $authorization;
         }
         // now create the implicit authorizations
         // the implicit authorizations will be created for all nodes
         // on the hierarchy path(s) between the node with the explicit authorization
         // and the node on which getAZs() was called.
         // If the row's qualifier and agent are what we asked for however,
         // then the AZ is explicit and doesn't need an implicit AZ as well.
         if ((!$returnExplicitOnly || $searchUp) && ($row['qid'] != $qId || $aId && $row['aid'] != $aId)) {
             // 				printpre("Building Implicit AZs...");
             // 				var_dump($returnExplicitOnly);
             // 				var_dump($searchUp);
             // if this is an AZ that is implicit because of a group instead
             // of because of the hierarchy, create it.
             if ($row['qid'] == $qId && $row['aid'] != $aId) {
                 // 					printpre("In first clause (AuthorizationCache)");
                 $qualifierId = $idManager->getId($qId);
                 // If we are getting implicit AZs for a given agent, make sure
                 // that the implicit AZ has their Id.
                 if ($aId) {
                     $agentId = $idManager->getId($aId);
                 } else {
                     $agentId = $authorization->getAgentId();
                 }
                 $function = $authorization->getFunction();
                 $functionId = $function->getId();
                 $effectiveDate = $authorization->getEffectiveDate();
                 $expirationDate = $authorization->getExpirationDate();
                 $implicit = new HarmoniAuthorization(null, $agentId, $functionId, $qualifierId, false, $this, $effectiveDate, $expirationDate);
                 $azHash = $agentId->getIdString() . "::" . $functionId->getIdString() . "::" . $qualifierId->getIdString();
                 if (!in_array($azHash, $createdImplicitAZs)) {
                     $authorizations[] = $implicit;
                     $createdImplicitAZs[] = $azHash;
                 }
             } else {
                 if (!$returnExplicitOnly && $qId) {
                     // 					printpre("In second clause (AuthorizationCache)");
                     // If we are getting implicit AZs for a given agent, make sure
                     // that the implicit AZ has their Id.
                     if ($aId) {
                         $agentId = $idManager->getId($aId);
                     } else {
                         $agentId = $authorization->getAgentId();
                     }
                     $function = $authorization->getFunction();
                     $functionId = $function->getId();
                     $effectiveDate = $authorization->getEffectiveDate();
                     $expirationDate = $authorization->getExpirationDate();
                     $implicitQualifierId = $idManager->getId($qId);
                     $implicit = new HarmoniAuthorization(null, $agentId, $functionId, $implicitQualifierId, false, $this, $effectiveDate, $expirationDate);
                     $azHash = $agentId->getIdString() . "::" . $functionId->getIdString() . "::" . $implicitQualifierId->getIdString();
                     if (!in_array($azHash, $createdImplicitAZs)) {
                         $authorizations[] = $implicit;
                         $createdImplicitAZs[] = $azHash;
                     }
                 } else {
                     if (!$returnExplicitOnly) {
                         printpre($row);
                         printpre("In third clause (AuthorizationCache)");
                         $explicitQualifier = $authorization->getQualifier();
                         $explicitQualifierId = $explicitQualifier->getId();
                         // If we are getting implicit AZs for a given agent, make sure
                         // that the implicit AZ has their Id.
                         if ($aId) {
                             $agentId = $idManager->getId($aId);
                         } else {
                             $agentId = $authorization->getAgentId();
                         }
                         $function = $authorization->getFunction();
                         $functionId = $function->getId();
                         $effectiveDate = $authorization->getEffectiveDate();
                         $expirationDate = $authorization->getExpirationDate();
                         // this is set 2
                         $authZManager = Services::getService("AuthZ");
                         $hierarchies = $authZManager->getQualifierHierarchies();
                         while ($hierarchies->hasNext()) {
                             $hierarchyId = $hierarchies->next();
                             $hierarchy = $hierarchyManager->getHierarchy($hierarchyId);
                             $timer = new Timer();
                             $timer->start();
                             $nodes = $hierarchy->traverse($explicitQualifierId, Hierarchy::TRAVERSE_MODE_DEPTH_FIRST, Hierarchy::TRAVERSE_DIRECTION_DOWN, Hierarchy::TRAVERSE_LEVELS_ALL);
                             $timer->end();
                             printf("LoadAZTime: %1.6f <br/>", $timer->printTime());
                             // now get the id of each node and store in array
                             $set2 = array();
                             // skip the first node
                             $nodes->next();
                             while ($nodes->hasNext()) {
                                 $info = $nodes->next();
                                 $nodeId = $info->getNodeId();
                                 $implicit = new HarmoniAuthorization(null, $agentId, $functionId, $nodeId, false, $this, $effectiveDate, $expirationDate);
                                 $azHash = $agentId->getIdString() . "::" . $functionId->getIdString() . "::" . $nodeId->getIdString();
                                 // 							printpre($azHash);
                                 // Weird bugs were happening, with $createdImplicitAZs
                                 // but I can't figure out what is going on.
                                 if (!in_array($azHash, $createdImplicitAZs)) {
                                     $authorizations[] = $implicit;
                                     // 								$createdImplicitAZs[] = $azHash;
                                 }
                             }
                         }
                     }
                 }
             }
         }
         $queryResult->advanceRow();
     }
     $queryResult->free();
     return $authorizations;
 }
 /**
  * Answer An AZ query for implicit AZs
  * 
  * @param array $agentIds The agent Ids to match
  * @param string fId The string id of a function.
  * @param string qId The string id of a qualifier. This parameter can not be null
  * and used as a wildmark.
  * @param object fType The type of a function.
  * @param boolean isActiveNow If True, only active Authorizations will be returned.
  * @return SelectQueryInterface 
  * @access protected
  * @since 4/23/08
  */
 protected function getImplicitAZQuery(array $agentIds, $fId, $qId, $fType, $isActiveNow)
 {
     $query = new SelectQuery();
     $query->addColumn("fk_explicit_az");
     $query->addColumn("id", "id", "az2_implicit_az");
     $query->addColumn("fk_agent", "aid");
     $query->addColumn("fk_function", "fid");
     $query->addColumn("fk_qualifier", "qid");
     $query->addColumn("effective_date", "eff_date");
     $query->addColumn("expiration_date", "exp_date");
     $query->addTable("az2_implicit_az");
     // now include criteria
     // the qualifiers criteria
     if (isset($qId)) {
         $query->addWhereEqual('fk_qualifier', $qId);
     }
     // the agent criteria
     if (count($agentIds)) {
         $query->addWhereIn('fk_agent', $agentIds);
     }
     // the function criteria
     if (isset($fId)) {
         $joinc = "az2_implicit_az.fk_function = az2_function.id";
         $query->addTable("az2_function", INNER_JOIN, $joinc);
         $query->addWhereEqual("fk_function", $fId);
     }
     // the function type criteria
     if (isset($fType)) {
         // do not join with az_function if we did already
         if (!isset($fId)) {
             $joinc = "az2_implicit_az.fk_function = az2_function.id";
             $query->addTable("az2_function", INNER_JOIN, $joinc);
         }
         // now join with type
         $joinc = "az2_function.fk_type = az2_function_type.id";
         $query->addTable("az2_function_type", INNER_JOIN, $joinc);
         $query->addWhereEqual("domain", $fType->getDomain());
         $query->addWhereEqual("authority", $fType->getAuthority());
         $query->addWhereEqual("keyword", $fType->getKeyword());
     }
     // the isActiveNow criteria
     if ($isActiveNow) {
         $where = "(effective_date IS NULL OR (NOW() >= effective_date))";
         $query->addWhere($where);
         $where = "(expiration_date IS NULL OR (NOW() < expiration_date))";
         $query->addWhere($where);
     }
     $query->addOrderBy("az2_implicit_az.id");
     return $query;
 }