/** * Constructor * @param mixed $schema Either a {@link Schema} object or a string ID of the schema to use. * @param optional boolean $verControl If set to TRUE this DMRecord will use version-control. * @param optional int $fetchMode USED INTERNALLY */ function DMRecord($schema, $verControl = false, $fetchMode = RECORD_FULL) { ArgumentValidator::validate($verControl, BooleanValidatorRule::getRule()); // ArgumentValidator::validate($schema, ExtendsValidatorRule::getRule("Schema")); if (is_object($schema)) { $schemaID = $schema->getID(); } else { $schemaID = $schema; } // it's a string (we hope) $schemaManager = Services::getService("SchemaManager"); $schema = $schemaManager->getSchemaByID($schemaID); $schema->load(); $this->_schema = $schema; $this->_fields = array(); $this->_versionControlled = $verControl; $this->_fetchMode = $fetchMode; $this->_fetchedValueIDs = array(); $this->_creationDate = DateAndTime::now(); $this->_myID = null; $this->_delete = false; // set up the individual fields foreach ($schema->getAllIDs(true) as $label) { $def = $schema->getField($label); $this->_fields[$label] = new RecordField($def, $this); unset($def); } $this->_idManager = Services::getService("Id"); }
/** * Stores the configuration. Calls the parent configuration first, * then does additional operations. * * @param object Properties $configuration * @return object * @access public * @since 3/24/05 */ function assignConfiguration(Properties $configuration) { parent::assignConfiguration($configuration); // Validate the configuration options we use: ArgumentValidator::validate($this->_configuration->getProperty('properties_fields'), ArrayValidatorRuleWithRule::getRule(StringValidatorRule::getRule())); ArgumentValidator::validate($this->_configuration->getProperty('database_id'), IntegerValidatorRule::getRule()); ArgumentValidator::validate($this->_configuration->getProperty('authentication_table'), StringValidatorRule::getRule()); ArgumentValidator::validate($this->_configuration->getProperty('username_field'), StringValidatorRule::getRule()); ArgumentValidator::validate($this->_configuration->getProperty('password_field'), StringValidatorRule::getRule()); ArgumentValidator::validate($this->_configuration->getProperty('allow_token_addition'), OptionalRule::getRule(BooleanValidatorRule::getRule())); ArgumentValidator::validate($this->_configuration->getProperty('allow_token_deletion'), OptionalRule::getRule(BooleanValidatorRule::getRule())); ArgumentValidator::validate($this->_configuration->getProperty('allow_token_updates'), OptionalRule::getRule(BooleanValidatorRule::getRule())); ArgumentValidator::validate($this->_configuration->getProperty('allow_property_updates'), OptionalRule::getRule(BooleanValidatorRule::getRule())); }
/** * Tests different types of validations. */ function test_All_Sorts_Of_Values() { // test a plain string $this->assertTrue(ArgumentValidator::validate("Hello!", StringValidatorRule::getRule(), true)); // test numeric values $this->assertTrue(ArgumentValidator::validate("23.21E10", NumericValidatorRule::getRule(), true)); $this->assertTrue(ArgumentValidator::validate(23, NumericValidatorRule::getRule(), true)); $this->assertTrue(ArgumentValidator::validate(23.21, NumericValidatorRule::getRule(), true)); // test integer values $this->assertTrue(ArgumentValidator::validate(23, IntegerValidatorRule::getRule(), true)); // test string values $this->assertTrue(ArgumentValidator::validate("23", StringValidatorRule::getRule(), true)); // test email values $this->assertTrue(ArgumentValidator::validate("*****@*****.**", EmailValidatorRule::getRule(), true)); $this->assertFalse(ArgumentValidator::validate("dradichk@middlebury", EmailValidatorRule::getRule(), false), "Gabe, fix this! Your EmailValidatorRule is faulty!"); // test boolean values $this->assertTrue(ArgumentValidator::validate(true, BooleanValidatorRule::getRule(), true)); $this->assertFalse(ArgumentValidator::validate("HOHO", BooleanValidatorRule::getRule(), false), "Gabe, fix this! Your BooleanValidatorRule is faulty!\nIn fact, I think you should just use is_bool() in your check() function."); }
/** * Assign the configuration of this Manager. Valid configuration options are as * follows: * * thumbnail_format string (ex: 'image/jpeg') * * use_gd boolean I * gd_formats array of strings (ex: array('image/jpeg', 'image/png')) * An empty array indicates any/all supported formats. * * use_imagemagick boolean * * imagemagick_path string (ex: 'usr/bin' OR '/usr/X11R6/bin') * * imagemagick_temp_dir string (ex: '/tmp') * * imagemagick_formats array of strings (ex: array('image/jpeg', 'image/png')) * An empty array indicates any/all supported formats. * * @param object Properties $configuration (original type: java.util.Properties) * * @throws object OsidException An exception with one of the following * messages defined in org.osid.OsidException: {@link * org.osid.OsidException#OPERATION_FAILED OPERATION_FAILED}, * {@link org.osid.OsidException#PERMISSION_DENIED * PERMISSION_DENIED}, {@link * org.osid.OsidException#CONFIGURATION_ERROR * CONFIGURATION_ERROR}, {@link * org.osid.OsidException#UNIMPLEMENTED UNIMPLEMENTED}, {@link * org.osid.OsidException#NULL_ARGUMENT NULL_ARGUMENT} * * @access public */ function assignConfiguration(Properties $configuration) { $this->_configuration = $configuration; ArgumentValidator::validate($configuration->getProperty('thumbnail_format'), StringValidatorRule::getRule()); ArgumentValidator::validate($configuration->getProperty('use_gd'), BooleanValidatorRule::getRule()); ArgumentValidator::validate($configuration->getProperty('gd_formats'), ArrayValidatorRuleWithRule::getRule(StringValidatorRule::getRule())); ArgumentValidator::validate($configuration->getProperty('use_imagemagick'), BooleanValidatorRule::getRule()); ArgumentValidator::validate($configuration->getProperty('imagemagick_path'), StringValidatorRule::getRule()); ArgumentValidator::validate($configuration->getProperty('imagemagick_temp_dir'), StringValidatorRule::getRule()); ArgumentValidator::validate($configuration->getProperty('imagemagick_formats'), ArrayValidatorRuleWithRule::getRule(StringValidatorRule::getRule())); $this->_thumbnailFormat = $configuration->getProperty('thumbnail_format'); $this->_useGD = $configuration->getProperty('use_gd'); $this->_gdFormats = $configuration->getProperty('gd_formats'); $this->_useImageMagick = $configuration->getProperty('use_imagemagick'); $this->_ImageMagickPath = $configuration->getProperty('imagemagick_path'); $this->_ImageMagickTempDir = $configuration->getProperty('imagemagick_temp_dir'); $this->_ImageMagickFormats = $configuration->getProperty('imagemagick_formats'); if ($this->_useGD) { $this->_gdProcessor = new GDProcessor($configuration->getProperty('thumbnail_format')); } if ($this->_useImageMagick) { $this->_ImageMagickProcessor = new ImageMagickProcessor($configuration->getProperty('thumbnail_format'), $this->_ImageMagickPath, $this->_ImageMagickTempDir); } }
/** * Constructor -- sets up the allowed fields for this kind of {@link DataContainer} * * @see DataContainer * @access public * @return void */ function HarmoniConfig() { // initialize the data container $this->init(); // add the fields we want to allow $message = "HarmoniConfig - the option 'defaultAction' must be set to a string value!"; $type = "Harmoni"; $this->add("defaultAction", StringValidatorRule::getRule(), $message, $type); $this->add("defaultAction", FieldRequiredValidatorRule::getRule(), $message, $type); unset($message, $type); $message = "HarmoniConfig - the option 'defaultModule' must be set to a string value!"; $type = "Harmoni"; $this->add("defaultModule", StringValidatorRule::getRule(), $message, $type); $this->add("defaultModule", FieldRequiredValidatorRule::getRule(), $message, $type); $message = "HarmoniConfig - if specified, the option 'defaultParams' must be set to a an array of string values!"; $this->add("defaultParams", OptionalRule::getRule(ArrayValidatorRuleWithRule::getRule(StringValidatorRule::getRule())), $message, $type); $this->add("programTitle", StringValidatorRule::getRule(), $message, $type); $this->add("sessionName", FieldRequiredValidatorRule::getRule()); $this->set("sessionName", "Harmoni"); $this->add("sessionUseCookies", BooleanValidatorRule::getRule()); $this->set("sessionUseCookies", true); $this->add("sessionUseOnlyCookies", BooleanValidatorRule::getRule()); $this->set("sessionUseOnlyCookies", true); $this->add("sessionCookiePath", FieldRequiredValidatorRule::getRule()); $this->set("sessionCookiePath", "/"); $this->add("sessionCookieDomain", StringValidatorRule::getRule(), "HarmoniConfig - You must set the 'sessionDomain' to the DNS domain you would like your session cookie sent to! (eg, '.mydomain.com')", "Harmoni"); $this->set("sessionCookieDomain", ""); // default // An array of module.action in which session ids are allowed to be passed in the // url $this->add("sessionInUrlActions", OptionalRule::getRule(ArrayValidatorRuleWithRule::getRule(StringValidatorRule::getRule())), $message, $type); $this->add("sessionCookiesSecure", BooleanValidatorRule::getRule()); $this->set("sessionCookiesSecure", false); $this->add("sessionCookiesHttpOnly", BooleanValidatorRule::getRule()); $this->set("sessionCookiesHttpOnly", true); }
/** * Return <code>true</code> if the Member or Group is in the Group, * optionally including subgroups, <code>false</code> otherwise. * * @param object Agent $memberOrGroup * @param boolean $searchSubgroups * * @return boolean * * @throws object AgentException An exception with one of the * following messages defined in org.osid.agent.AgentException may * be thrown: {@link * org.osid.agent.AgentException#OPERATION_FAILED * OPERATION_FAILED}, {@link * org.osid.agent.AgentException#PERMISSION_DENIED * PERMISSION_DENIED}, {@link * org.osid.agent.AgentException#CONFIGURATION_ERROR * CONFIGURATION_ERROR}, {@link * org.osid.agent.AgentException#UNIMPLEMENTED UNIMPLEMENTED}, * {@link org.osid.agent.AgentException#NULL_ARGUMENT * NULL_ARGUMENT} * * @access public */ function contains(Agent $memberOrGroup, $searchSubgroups) { ArgumentValidator::validate($searchSubgroups, BooleanValidatorRule::getRule(), true); // ** end of parameter validation $id = $memberOrGroup->getId(); $children = $this->getMembers($searchSubgroups); while ($children->hasNext()) { if ($id->isEqual($children->next()->getId())) { return true; } } $children = $this->getGroups($searchSubgroups); while ($children->hasNext()) { if ($id->isEqual($children->next()->getId())) { return true; } } return FALSE; }
/** * Assign the configuration of this Manager. Valid configuration options are as * follows: * hierarchy_id string * root_id string * course_management_id string * canonical_courses_id string * course_groups_id string * * @param object Properties $configuration (original type: java.util.Properties) * * @throws object OsidException An exception with one of the following * messages defined in org.osid.OsidException: {@link * org.osid.OsidException#OPERATION_FAILED OPERATION_FAILED}, * {@link org.osid.OsidException#PERMISSION_DENIED * PERMISSION_DENIED}, {@link * org.osid.OsidException#CONFIGURATION_ERROR * CONFIGURATION_ERROR}, {@link * org.osid.OsidException#UNIMPLEMENTED UNIMPLEMENTED}, {@link * org.osid.OsidException#NULL_ARGUMENT NULL_ARGUMENT} * * @access public */ function assignConfiguration(Properties $configuration) { $this->_configuration = $configuration; $hierarchyId = $configuration->getProperty('hierarchy_id'); $courseManagementId = $configuration->getProperty('course_management_id'); $terms = $configuration->getProperty('terms_to_add'); $makeTerms = $configuration->getProperty('whether_to_add_terms'); $authority = $configuration->getProperty('authority'); // ** parameter validation ArgumentValidator::validate($hierarchyId, StringValidatorRule::getRule(), true); ArgumentValidator::validate($courseManagementId, StringValidatorRule::getRule(), true); ArgumentValidator::validate($makeTerms, BooleanValidatorRule::getRule(), true); ArgumentValidator::validate($authority, StringValidatorRule::getRule(), true); // ** end of parameter validation //convert to ids $idManager = Services::getService("Id"); $hierarchyId = $idManager->getId($hierarchyId); $canonicalCoursesId = $idManager->getId($courseManagementId . ".canonicalcourses"); $courseGroupsId = $idManager->getId($courseManagementId . ".coursegroups"); $courseManagementId = $idManager->getId($courseManagementId); $hierarchyManager = Services::getService("Hierarchy"); $this->_hierarchy = $hierarchyManager->getHierarchy($hierarchyId); $this->_courseManagementRootId = $courseManagementId; $this->_canonicalCoursesId = $canonicalCoursesId; $this->_courseGroupsId = $courseGroupsId; //terms if ($makeTerms) { if (!isset($_SESSION['terms_have_been_taken_care_of'])) { /********************************************************* * Check for existing data in the database *********************************************************/ $dbManager = Services::getService("DatabaseManager"); $query = new SelectQuery(); $query->addTable('cm_term'); $query->addColumn('id'); $res = $dbManager->query($query); //create terms only if the term table is empty if (!$res->hasMoreRows()) { $sm = Services::getService("Scheduling"); foreach ($terms as $array) { $name = $array['name']; $start = $array['start']->asUnixTimeStamp() * 1000; $end = $array['end']->asUnixTimeStamp() * 1000 - 1; $type = new Type("ScheduleItemStatusType", $authority, "Autogenerated Term"); $schedule[0] = $sm->v3_createScheduleItem($name . " range", "The start and end of the " . $name . " Term", $type, $start, $end, null); $term = $this->createTerm($array['type'], $schedule); $term->updateDisplayName($name); } $_SESSION['table_setup_complete'] = TRUE; } } } }
/** * The constructor. * @param object id The id of this Authorization * @param ref object agentId The Id of the agent. * @param ref object functionId The Id of the function. * @param ref object qualifierId The Id of the qualifier. * @param integer effectiveDate The date when the authorization becomes effective. * @param integer expirationDate The date when the authorization expires. * @param boolean explicit Specifies whether this Authorization is explicit or not. * @access public */ function __construct($id, Id $agentId, Id $functionId, Id $qualifierId, $explicit, AuthZ2_AuthorizationCache $cache, $effectiveDate = NULL, $expirationDate = NULL) { // ** parameter validation ArgumentValidator::validate($id, OptionalRule::getRule(StringValidatorRule::getRule()), true); ArgumentValidator::validate($effectiveDate, OptionalRule::getRule(HasMethodsValidatorRule::getRule('asDateAndTime')), true); ArgumentValidator::validate($expirationDate, OptionalRule::getRule(HasMethodsValidatorRule::getRule('asDateAndTime')), true); ArgumentValidator::validate($explicit, BooleanValidatorRule::getRule(), true); // ** end of parameter validation // make sure effective date is before expiration date if (isset($effectiveDate) && isset($expirationDate)) { if ($effectiveDate > $expirationDate) { $str = "The effective date must be before the expiration date."; throwError(new Error($str, "Authorization", true)); } } $this->_id = $id; $this->_agentId = $agentId; $this->_functionId = $functionId; $this->_qualifierId = $qualifierId; if (isset($effectiveDate)) { $this->_effectiveDate = $effectiveDate; } if (isset($expirationDate)) { $this->_expirationDate = $expirationDate; } $this->_explicit = $explicit; $this->_cache = $cache; }
/** * Given a FunctionType and a qualifierId returns all Authorizations that * would allow Agents to do Functions in the FunctionType with the * Qualifier. This method differs from getAuthorizations in that this * method looks for any Authorization that permits doing the Function with * the Qualifier even if the Authorization's Qualifier happens to be a * parent of the Qualifier argument. * * @param object Id $agentId * @param object Type $functionType * @param object Id $qualifierId * @param boolean $isActiveNowOnly * * @return object AuthorizationIterator * * @throws object AuthorizationException An exception with * one of the following messages defined in * org.osid.authorization.AuthorizationException may be thrown: * {@link * org.osid.authorization.AuthorizationException#OPERATION_FAILED * OPERATION_FAILED}, {@link * org.osid.authorization.AuthorizationException#PERMISSION_DENIED * PERMISSION_DENIED}, {@link * org.osid.authorization.AuthorizationException#CONFIGURATION_ERROR * CONFIGURATION_ERROR}, {@link * org.osid.authorization.AuthorizationException#UNIMPLEMENTED * UNIMPLEMENTED}, {@link * org.osid.authorization.AuthorizationException#NULL_ARGUMENT * NULL_ARGUMENT}, {@link * org.osid.authorization.AuthorizationException#UNKNOWN_ID * UNKNOWN_ID}, {@link * org.osid.authorization.AuthorizationException#UNKNOWN_TYPE * UNKNOWN_TYPE} * * @access public */ function getAllAZsByFuncType(Id $agentId, Type $functionType, Id $qualifierId, $isActiveNowOnly) { // ** parameter validation ArgumentValidator::validate($isActiveNowOnly, BooleanValidatorRule::getRule(), true); // ** end of parameter validation $authorizations = $this->_cache->getAZs($agentId->getIdString(), null, $qualifierId->getIdString(), $functionType, false, $isActiveNowOnly, $this->_getContainingGroupIdStrings($agentId)); $i = new AuthZ2_AuthorizationIterator($authorizations); return $i; }
/** * Sets the selected state of this menu item. * @access public * @param boolean selected <code>TRUE</code> means selected; <code>FALSE</code> * is unselected. **/ function setSelected($selected) { // ** parameter validation ArgumentValidator::validate($selected, BooleanValidatorRule::getRule(), true); // ** end of parameter validation $this->_selected = $selected; $type = $selected ? MENU_ITEM_LINK_SELECTED : MENU_ITEM_LINK_UNSELECTED; $this->_type = $type; }
/** * Traverses the tree and returns all the nodes in an array. The traversal * is a depth-first pre-order traversal starting from the specified node. * @access public * @param ref object node The node to start traversal from. * @param boolean down If <code>true</code>, this argument specifies that the traversal will * go down the children; if <code>false</code> then it will go up the parents. * @param integer levels Specifies how many levels of nodes remain to be fetched. This * will be recursively decremented and at 0 the recursion will stop. If this is negative * then the recursion will go on until the last level is processed. * @return ref array An array of all nodes in the tree visited in a pre-order * manner. The keys of the array correspond to the nodes' ids. * Each element of the array is another array of two elements, the first * being the node itself, and the second being the depth of the node relative * to the starting node. Descendants are assigned increasingly positive levels; * ancestors increasingly negative levels. */ function traverse($node, $down, $levels) { // ** parameter validation $extendsRule = ExtendsValidatorRule::getRule("TreeNodeInterface"); ArgumentValidator::validate($node, $extendsRule, true); ArgumentValidator::validate($down, BooleanValidatorRule::getRule(), true); ArgumentValidator::validate($levels, IntegerValidatorRule::getRule(), true); // ** end of parameter validation if (!$this->nodeExists($node->getId())) { $str = "Attempted to traverse from a node that does not exist in the tree."; throwError(new Error($str, "Hierarchy", true)); } $cacheKey = $this->getCacheKey($node, $down, $levels); if (!isset($this->_traversalCache[$cacheKey])) { $this->_traversalCache[$cacheKey] = array(); $this->_traverse($this->_traversalCache[$cacheKey], $node, $down, $levels, $levels); } return $this->_traversalCache[$cacheKey]; }
/** * Sets if this field is allowed to have multiple values. * @param bool $mult * @return void * @access public */ function setMultFlag($mult) { ArgumentValidator::validate($mult, BooleanValidatorRule::getRule()); $this->_mult = $mult; }
/** * 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; }
/** * Duplicate a RecordStructure, optionally duplicating the records as well, * also optionally deleting the records in the original RecordStructure. * * Use this method to convert from data stored in a 'global' RecordStructure * such as DublinCore into a 'local' version of the RecordStructure Core in which the * user has the option of customizing fields. * * As well, this method can be used to convert a RecordStructure and associated * Records to a local version if the RecordStructure was accidentally created * as a 'global' one. * * WARNING: NOT IN OSID * * @param object Id $recordStructureId The id of the RecordStructure to duplicate * @param boolean $copyRecords If true, existing records will be duplicated * under the new RecordStructure. * @param optional object $id An optional id for the new RecordStructure * @param optional boolean $isGlobal If true the new RecordStructure will be made a global one. * @param optional object $statusStars A status indicator to use if passed. * @return void * @access public * @since 6/7/06 */ function duplicateRecordStructure(Id $recordStructureId, $copyRecords = FALSE, $id = null, $isGlobal = FALSE, $statusStars = null) { ArgumentValidator::validate($recordStructureId, ExtendsValidatorRule::getRule("Id")); ArgumentValidator::validate($copyRecords, BooleanValidatorRule::getRule()); ArgumentValidator::validate($id, OptionalRule::getRule(ExtendsValidatorRule::getRule("Id"))); ArgumentValidator::validate($isGlobal, BooleanValidatorRule::getRule()); $oldRecStruct = $this->getRecordStructure($recordStructureId); $newRecStruct = $this->createRecordStructure($oldRecStruct->getDisplayName() . _(" Copy"), $oldRecStruct->getDescription(), $oldRecStruct->getFormat(), $oldRecStruct->getSchema(), $id, $isGlobal); $mapping = array(); $oldPartStructs = $oldRecStruct->getPartStructures(); while ($oldPartStructs->hasNext()) { $oldPartStruct = $oldPartStructs->next(); $newPartStruct = $newRecStruct->createPartStructure($oldPartStruct->getDisplayName(), $oldPartStruct->getDescription(), $oldPartStruct->getType(), $oldPartStruct->isMandatory(), $oldPartStruct->isRepeatable(), $oldPartStruct->isPopulatedByRepository()); // Mapping $oldPartStructId = $oldPartStruct->getId(); $mapping[$oldPartStructId->getIdString()] = $newPartStruct->getId(); } unset($oldPartStruct, $newPartStruct); if ($copyRecords) { $assets = $this->getAssets(); if (!is_null($statusStars)) { $statusStars->initializeStatistics($assets->count()); } while ($assets->hasNext()) { $asset = $assets->next(); $oldRecords = $asset->getRecordsByRecordStructure($oldRecStruct->getId()); while ($oldRecords->hasNext()) { $oldRecord = $oldRecords->next(); // Create the new Record $newRecord = $asset->createRecord($newRecStruct->getId()); $oldParts = $oldRecord->getParts(); while ($oldParts->hasNext()) { $oldPart = $oldParts->next(); $oldPartStruct = $oldPart->getPartStructure(); $oldPartStructId = $oldPartStruct->getId(); $newPart = $newRecord->createPart($mapping[$oldPartStructId->getIdString()], $oldPart->getValue()); } } if (!is_null($statusStars)) { $statusStars->updateStatistics(); } } } return $newRecStruct; }
/** * Create an PartStructure in this RecordStructure. This is not part of the Repository OSID at * the time of this writing, but is needed for dynamically created * RecordStructures/PartStructures. * * @param string $displayName The DisplayName of the new RecordStructure. * @param string $description The Description of the new RecordStructure. * @param object Type $type One of the InfoTypes supported by this implementation. * E.g. string, shortstring, blob, datetime, integer, float, * * @param boolean $isMandatory True if the PartStructure is Mandatory. * @param boolean $isRepeatable True if the PartStructure is Repeatable. * @param boolean $isPopulatedByDR True if the PartStructure is PopulatedBy the DR. * @param optional object $id An optional {@link HarmoniId} object for this part structure. * * @return object PartStructure The newly created PartStructure. */ function createPartStructure($displayName, $description, Type $partType, $isMandatory, $isRepeatable, $isPopulatedByRepository, $theid = null) { ArgumentValidator::validate($displayName, StringValidatorRule::getRule()); ArgumentValidator::validate($description, StringValidatorRule::getRule()); ArgumentValidator::validate($partType, ExtendsValidatorRule::getRule("Type")); ArgumentValidator::validate($isMandatory, BooleanValidatorRule::getRule()); ArgumentValidator::validate($isRepeatable, BooleanValidatorRule::getRule()); ArgumentValidator::validate($isPopulatedByRepository, BooleanValidatorRule::getRule()); if ($theid == null) { $idManager = Services::getService("Id"); $id = $idManager->createId(); $label = $id->getIdString(); } else { // check if this ID follows our Schema's ID $id = $theid; if (strpos($id->getIdString(), $this->_schema->getID()) != 0) { throwError(new Error("Could not create PartStructure -- the passed ID does not conform to the Schema's internal ID: " . $this->_schema->getID(), "Repository", true)); } $label = str_replace($this->_schema->getID() . ".", "", $id->getIdString()); } $fieldDef = new SchemaField($label, $displayName, $partType->getKeyword(), $description, $isRepeatable, $isMandatory); $schema = $this->_schema->deepCopy(); $schema->addField($fieldDef); $sm = Services::getService("SchemaManager"); $sm->synchronize($schema); $this->_schema = $sm->getSchemaByID($this->_schema->getID()); $idString = $this->_schema->getFieldIDFromLabel($label); $this->_createdParts[$idString] = new HarmoniPartStructure($this->manager, $this, $fieldDef, $this->_repositoryId); return $this->_createdParts[$idString]; }
/** * Performs a depth-first pre-order traversal. It either returns the previously cached nodes * or fetches them from the database and then caches them (depending on whtether * they had been already cached). * @access public * @param object id The id of the node where to start traversal from. * @param boolean down If <code>true</code>, this argument specifies that the traversal will * go down the children; if <code>false</code> then it will go up the parents. * @param integer levels Specifies how many levels of nodes to traverse. If this is negative * then the traversal will go on until the last level is processed. * @return ref array An array of all nodes in the tree visited in a pre-order * manner. **/ function traverse($id, $down, $levels) { // ** parameter validation ArgumentValidator::validate($id, ExtendsValidatorRule::getRule("Id"), true); ArgumentValidator::validate($down, BooleanValidatorRule::getRule(), true); ArgumentValidator::validate($levels, IntegerValidatorRule::getRule(), true); // ** end of parameter validation // get the id value $idValue = $id->getIdString(); // see if the nodes have already been cached, if so // there is no need to access the database, but if not, // then hell yeah, we gotta access the database. // the manner of traversing if completely different // for the 2 directions: therefore, execution splits here // BIG NOTE: It seems that efficient caching mechanisms with // partial fetching of the hierarchy (i.e. traversing with levels > 1) // is not feasible. Thus, this method will only take advantage of the cache // when traversing all the way down (levels < 0) or when getting the children // 1) GOING DOWN if ($down) { // if not cached, fetch from DB and cache! if (!$this->_isCachedDown($idValue, $levels)) { $this->_traverseDown($idValue, $levels); } } else { // if not cached, fetch from DB and cache! if (!$this->_isCachedUp($idValue, $levels)) { $this->_traverseUpAncestory($idValue, $levels); } // $this->_traverseUp($idValue, $levels); } // now that all nodes are cached, return them $treeNode = $this->_tree->getNode($idValue); $treeNodes = $this->_tree->traverse($treeNode, $down, $levels); $result = array(); foreach (array_keys($treeNodes) as $i => $key) { $node = $this->_cache[$key][0]; // If the node was deleted, but the cache still has a key for it, // continue. if (!is_object($node)) { continue; // throwError(new Error("Missing node object", "Hierarchy Cache")); } $nodeId = $node->getId(); if (!isset($this->_infoCache[$nodeId->getIdString()])) { $this->_infoCache[$nodeId->getIdString()] = new AuthZ2_TraversalInfo($nodeId, $node->getDisplayName(), $treeNodes[$key][1]); } $result[] = $this->_infoCache[$nodeId->getIdString()]; } $iterator = new AuthZ2_TraversalInfoIterator($result); return $iterator; }
/** * Specifies whether distinct rows will be returned. * * Use this method to specify whether the rows returned by the SELECT query * have to be distinct (i.e. only unique rows) or not. If the method is never * called, then the default value is not distinct. * @param boolean $distinct If true, then only unique rows will be returned. * @access public */ function setDistinct($distinct) { // ** parameter validation $booleanRule = BooleanValidatorRule::getRule(); ArgumentValidator::validate($distinct, $booleanRule, true); // ** end of parameter validation $this->distinct($distinct); }
/** * Set the status of showControls. * * @param boolean $showControls * @return void * @access private * @since 2/22/06 */ private final function setShowControls($showControls) { ArgumentValidator::validate($showControls, BooleanValidatorRule::getRule()); $this->_showControls = $showControls; }
/** * Optional: Set the GUID and isPermaLink * * @param string $guid * @param optional boolean $isPermaLink * @return void * @access public * @since 8/7/06 */ function setGUID($guid, $isPermaLink = true) { ArgumentValidator::validate($guid, StringValidatorRule::getRule()); ArgumentValidator::validate($isPermaLink, BooleanValidatorRule::getRule()); $this->_guid = $guid; $this->_isPermaLink = $isPermaLink; }
/** * Create a Hierarchy. * * @param string $displayName * @param object Type[] $nodeTypes * @param string $description * @param boolean $allowsMultipleParents * @param boolean $allowsRecursion * @param optional object Id $id WARNING: NOT IN OSID * * @return object Hierarchy * * @throws object HierarchyException An exception with one of * the following messages defined in * org.osid.hierarchy.HierarchyException may be thrown: {@link * org.osid.hierarchy.HierarchyException#OPERATION_FAILED * OPERATION_FAILED}, {@link * org.osid.hierarchy.HierarchyException#PERMISSION_DENIED * PERMISSION_DENIED}, {@link * org.osid.hierarchy.HierarchyException#CONFIGURATION_ERROR * CONFIGURATION_ERROR}, {@link * org.osid.hierarchy.HierarchyException#UNIMPLEMENTED * UNIMPLEMENTED}, {@link * org.osid.hierarchy.HierarchyException#NULL_ARGUMENT * NULL_ARGUMENT}, {@link * org.osid.hierarchy.HierarchyException#UNSUPPORTED_CREATION * UNSUPPORTED_CREATION} * * @access public */ function createHierarchy($displayName, array $nodeTypes, $description, $allowsMultipleParents, $allowsRecursion, Id $id = NULL) { // ** parameter validation ArgumentValidator::validate($description, StringValidatorRule::getRule(), true); ArgumentValidator::validate($displayName, StringValidatorRule::getRule(), true); ArgumentValidator::validate($allowsMultipleParents, BooleanValidatorRule::getRule(), true); ArgumentValidator::validate($allowsRecursion, BooleanValidatorRule::getRule(), true); ArgumentValidator::validate($id, OptionalRule::getRule(ExtendsValidatorRule::getRule("Id")), true); // ** end of parameter validation // check for supported hierarchies if ($allowsRecursion) { throw new OperationFailedException("Unsuported creation. Does not support recursion."); } $dbHandler = Services::getService("DatabaseManager"); // Create an Id for the Hierarchy if (!is_object($id)) { $idManager = Services::getService("Id"); $id = $idManager->createId(); } $idValue = $id->getIdString(); $query = new InsertQuery(); $query->setTable("az2_hierarchy"); $query->addValue("id", $idValue); $query->addValue("display_name", $displayName); $query->addValue("description", $description); $query->addValue("multiparent", $allowsMultipleParents ? '1' : '0'); $queryResult = $dbHandler->query($query, $this->_dbIndex); // Create a new hierarchy and insert it into the database $cache = new AuthZ2_HierarchyCache($idValue, $allowsMultipleParents, $this->_dbIndex, isset($this->harmoni_db) ? $this->harmoni_db : null); $cache->setAuthorizationManager($this->getAuthorizationManager()); $hierarchy = new AuthZ2_Hierarchy($id, $displayName, $description, $cache); // then cache it $this->_hierarchies[$idValue] = $hierarchy; return $hierarchy; }
function test_rule_set_add_multiple() { $this->assertEqual($this->testRuleSet->count(), 0); // what the hell is this??? // $error = 1; $error = new Error("UnitTest", "UnitTest", false); $rq = FieldRequiredValidatorRule::getRule(); $email = EmailValidatorRule::getRule(); $number = NumericValidatorRule::getRule(); $this->testRuleSet->addRule("mystring", $rq, $error); $this->testRuleSet->addRule("mystring", $email, $error); $this->testRuleSet->addRule("boolean", BooleanValidatorRule::getRule(), $error); $this->testRuleSet->addRule("mynumber", $number, $error); $this->assertEqual($this->testRuleSet->count(), 3); $this->assertReference($this->testRuleSet->_rules["mystring"][0][0], $rq); $this->assertReference($this->testRuleSet->_rules["mystring"][1][0], $email); $this->assertReference($this->testRuleSet->_rules["mynumber"][0][0], $number); // $this->assertEqual($this->testRuleSet->getKeys(), array("mystring","mynumber","boolean")); }
/** * 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 isActiveNow If True, only active Authorizations will be returned. * @return array **/ function getAZs($aId, $fId, $qId, $fType, $returnExplicitOnly, $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. // Agents/Groups if (isset($aId)) { $agentIds = array($aId); } else { $agentIds = array(); } $allAgentIds = array_merge($agentIds, $groupIds); $explicitQueryResult = $this->getExplicitAZQueryResult($allAgentIds, $fId, $qId, $fType, $isActiveNow); if ($returnExplicitOnly) { return $this->getAuthorizationsFromQueryResult($explicitQueryResult, $aId, $qId, $returnExplicitOnly); } else { $implicitQueryResult = $this->getImplicitAZQueryResult($allAgentIds, $fId, $qId, $fType, $isActiveNow); return array_merge($this->getAuthorizationsFromQueryResult($explicitQueryResult, $aId, $qId, $returnExplicitOnly), $this->getAuthorizationsFromQueryResult($implicitQueryResult, $aId, $qId, $returnExplicitOnly)); } }