51    require_once(
"SeqActivity.php");
 
   53    require_once(
"SeqRule.php");
 
   54    require_once(
"SeqRuleset.php");
 
   56    require_once(
"SeqCondition.php");
 
   57    require_once(
"SeqConditionSet.php");
 
   59    require_once(
"SeqObjective.php");
 
   60    require_once(
"SeqObjectiveMap.php");
 
   62    require_once(
"SeqRollupRule.php");
 
   63    require_once(
"SeqRollupRuleset.php");
 
   65    require_once(
"ADLAuxiliaryResource.php");
 
   71            $doc = 
new DomDocument();
 
   79            $organization = $doc->getElementsByTagName(
"organization");
 
   82            foreach ($organization as $element) {
 
   83                if (preg_replace(
'/(%20)+/', 
' ', trim($element->getAttribute(
"identifier"))) == 
$default) {
 
   84                    $default_organization = $element;
 
   89            $seqCollection = $doc->getElementsByTagName(
"sequencingCollection")->item(0);
 
   91            $root = $this->
buildNode($default_organization, $seqCollection, $doc);
 
   94            $objectivesGlobalToSystem = $default_organization->getAttributeNS(
"http://www.adlnet.org/xsd/adlseq_v1p3", 
"objectivesGlobalToSystem");
 
   96            $org = preg_replace(
'/(%20)+/', 
' ', trim($default_organization->getAttribute(
"identifier")));
 
  101            if ($objectivesGlobalToSystem == 
"false") {
 
  106            $dataGlobalToSystem = $default_organization->getAttributeNS(
"http://www.adlnet.org/xsd/adlcp_v1p3", 
"sharedDataGlobalToSystem");
 
  109            $dataglobaltosystem = 1;
 
  111            if ($dataGlobalToSystem == 
"false") {
 
  112                $dataglobaltosystem = 0;
 
  116            $c_root[
'_SeqActivity'] = 
$root;
 
  118            $ret[
'global'] = $globaltosystem;
 
  119            $ret[
'dataglobal'] = $dataglobaltosystem;
 
  120            $ret[
'tree'] = $c_root;
 
  134            $act->setID(preg_replace(
'/(%20)+/', 
' ', trim($node->getAttribute(
"identifier"))));
 
  136            $tempVal = preg_replace(
'/(%20)+/', 
' ', trim($node->getAttribute(
"identifierref")));
 
  138                $act->setResourceID($tempVal);
 
  141            $tempVal = $node->getAttribute(
"isvisible");
 
  144                $act->setIsVisible(self::convert_to_bool($tempVal));
 
  150            $children = $node->childNodes;
 
  152            for (
$i = 0; 
$i < $children->length; 
$i++) {
 
  153                $curNode = $children->item(
$i);
 
  156                if ($curNode->nodeType == XML_ELEMENT_NODE) {
 
  158                    if ($curNode->localName == 
"item") {
 
  162                        $nestedAct = $this->
buildNode($curNode, $seq, $doc);
 
  163                        if ($nestedAct != 
null) {
 
  164                            $act->AddChild($nestedAct);
 
  166                    } elseif ($curNode->localName == 
"title") {
 
  168                    } elseif ($curNode->localName == 
"completionThreshold") {
 
  169                        $tempVal = $curNode->getAttribute(
"minProgressMeasure");
 
  172                            $act->setCompletionThreshold($tempVal);
 
  173                        } elseif ($curNode->nodeValue != 
null && $curNode->nodeValue != 
'') {
 
  174                            $act->setCompletionThreshold($curNode->nodeValue);
 
  177                        $tempVal = $curNode->getAttribute(
"progressWeight");
 
  180                            $act->setProgressWeight($tempVal);
 
  182                        $tempVal = $curNode->getAttribute(
"completedByMeasure");
 
  185                            $act->setCompletedByMeasure(self::convert_to_bool($tempVal));
 
  187                    } elseif ($curNode->localName == 
"sequencing") {
 
  190                        $tempVal = preg_replace(
'/(%20)+/', 
' ', trim($curNode->getAttribute(
"IDRef")));
 
  197                            $sequencing = $seq->getElementsByTagName(
"sequencing");
 
  200                            foreach ($sequencing as $element) {
 
  201                                if (preg_replace(
'/(%20)+/', 
' ', trim($element->getAttribute(
"ID"))) == $tempVal) {
 
  202                                    $seqGlobal = $element;
 
  207                            $seqInfo = $seqGlobal->cloneNode(
true);
 
  210                            $seqChildren = $curNode->childNodes;
 
  211                            for ($j = 0; $j < $seqChildren->length; $j++) {
 
  213                                $curChild = $seqChildren->item($j);
 
  214                                if ($curChild->nodeType == XML_ELEMENT_NODE) {
 
  217                                    $seqInfo->appendChild($curChild);
 
  229                $item = $children->item(
$i)->nodeValue;
 
  240            $children = $iNode->childNodes;
 
  241            for (
$i = 0; 
$i < $children->length; 
$i++) {
 
  242                $curNode = $children->item(
$i);
 
  243                if ($curNode->nodeType == XML_ELEMENT_NODE) {
 
  244                    if ($curNode->localName == 
"controlMode") {
 
  246                        $tempVal = $curNode->getAttribute(
"choice");
 
  248                            $ioAct->setControlModeChoice(self::convert_to_bool($tempVal));
 
  251                        $tempVal = $curNode->getAttribute(
"choiceExit");
 
  253                            $ioAct->setControlModeChoiceExit(self::convert_to_bool($tempVal));
 
  257                        $tempVal = $curNode->getAttribute(
"flow");
 
  259                            $ioAct->setControlModeFlow(self::convert_to_bool($tempVal));
 
  263                        $tempVal = $curNode->getAttribute(
"forwardOnly");
 
  265                            $ioAct->setControlForwardOnly(self::convert_to_bool($tempVal));
 
  269                        $tempVal = $curNode->getAttribute(
"useCurrentAttemptObjectiveInfo");
 
  271                            $ioAct->setUseCurObjective(self::convert_to_bool($tempVal));
 
  275                        $tempVal = $curNode->getAttribute(
"useCurrentAttemptProgressInfo");
 
  277                            $ioAct->setUseCurProgress(self::convert_to_bool($tempVal));
 
  279                    } elseif ($curNode->localName == 
"sequencingRules") {
 
  281                    } elseif ($curNode->localName == 
"limitConditions") {
 
  283                        $tempVal = $curNode->getAttribute(
"attemptLimit");
 
  285                            $ioAct->setAttemptLimit($tempVal);
 
  289                        $tempVal = $curNode->getAttribute(
"attemptAbsoluteDurationLimit");
 
  291                            $ioAct->setAttemptAbDur($tempVal);
 
  295                        $tempVal = $curNode->getAttribute(
"attemptExperiencedDurationLimit");
 
  297                            $ioAct->setAttemptExDur($tempVal);
 
  301                        $tempVal = $curNode->getAttribute(
"activityAbsoluteDurationLimit");
 
  303                            $ioAct->setActivityAbDur($tempVal);
 
  307                        $tempVal = $curNode->getAttribute(
"activityExperiencedDurationLimit");
 
  309                            $ioAct->setActivityExDur($tempVal);
 
  313                        $tempVal = $curNode->getAttribute(
"beginTimeLimit");
 
  315                            $ioAct->setBeginTimeLimit($tempVal);
 
  319                        $tempVal = $curNode->getAttribute(
"endTimeLimit");
 
  321                            $ioAct->setEndTimeLimit($tempVal);
 
  323                    } elseif ($curNode->localName == 
"auxiliaryResources") {
 
  325                    } elseif ($curNode->localName == 
"rollupRules") {
 
  327                    } elseif ($curNode->localName == 
"objectives" && $curNode->namespaceURI == 
"http://www.imsglobal.org/xsd/imsss") {
 
  329                    } elseif ($curNode->localName == 
"objectives" && $curNode->namespaceURI == 
"http://www.adlnet.org/xsd/adlseq_v1p3") {
 
  331                    } elseif ($curNode->localName == 
"randomizationControls") {
 
  334                        $tempVal = $curNode->getAttribute(
"randomizationTiming");
 
  336                            $ioAct->setRandomTiming($tempVal);
 
  340                        $tempVal = $curNode->getAttribute(
"selectCount");
 
  342                            $ioAct->setSelectCount($tempVal);
 
  346                        $tempVal = $curNode->getAttribute(
"reorderChildren");
 
  348                            $ioAct->setReorderChildren(self::convert_to_bool($tempVal));
 
  352                        $tempVal = $curNode->getAttribute(
"selectionTiming");
 
  354                            $ioAct->setSelectionTiming($tempVal);
 
  356                    } elseif ($curNode->localName == 
"deliveryControls") {
 
  359                        $tempVal = $curNode->getAttribute(
"tracked");
 
  361                            $ioAct->setIsTracked(self::convert_to_bool($tempVal));
 
  365                        $tempVal = $curNode->getAttribute(
"completionSetByContent");
 
  367                            $ioAct->setSetCompletion(self::convert_to_bool($tempVal));
 
  371                        $tempVal = $curNode->getAttribute(
"objectiveSetByContent");
 
  373                            $ioAct->setSetObjective(self::convert_to_bool($tempVal));
 
  375                    } elseif ($curNode->localName == 
"constrainedChoiceConsiderations") {
 
  378                        $tempVal = $curNode->getAttribute(
"preventActivation");
 
  380                            $ioAct->setPreventActivation(self::convert_to_bool($tempVal));
 
  384                        $tempVal = $curNode->getAttribute(
"constrainChoice");
 
  386                            $ioAct->setConstrainChoice(self::convert_to_bool($tempVal));
 
  388                    } elseif ($curNode->localName == 
"rollupConsiderations") {
 
  391                        $tempVal = $curNode->getAttribute(
"requiredForSatisfied");
 
  393                            $ioAct->setRequiredForSatisfied($tempVal);
 
  397                        $tempVal = $curNode->getAttribute(
"requiredForNotSatisfied");
 
  399                            $ioAct->setRequiredForNotSatisfied($tempVal);
 
  403                        $tempVal = $curNode->getAttribute(
"requiredForCompleted");
 
  405                            $ioAct->setRequiredForCompleted($tempVal);
 
  409                        $tempVal = $curNode->getAttribute(
"requiredForIncomplete");
 
  411                            $ioAct->setRequiredForIncomplete($tempVal);
 
  415                        $tempVal = $curNode->getAttribute(
"measureSatisfactionIfActive");
 
  417                            $ioAct->setSatisfactionIfActive(self::convert_to_bool($tempVal));
 
  435            $objectives = array();
 
  436            $children = $iNode->childNodes;
 
  437            for (
$i = 0; 
$i < $children->length; 
$i++) {
 
  438                $curNode = $children->item(
$i);
 
  439                if ($curNode->nodeType == XML_ELEMENT_NODE) {
 
  440                    if ($curNode->localName == 
"primaryObjective" || $curNode->localName == 
"objective") {
 
  442                        if ($curNode->localName == 
"primaryObjective") {
 
  443                            $obj->mContributesToRollup = 
true;
 
  447                        $tempVal = preg_replace(
'/(%20)+/', 
' ', trim($curNode->getAttribute(
"objectiveID")));
 
  449                            $obj->mObjID = $tempVal;
 
  453                        $tempVal = $curNode->getAttribute(
"satisfiedByMeasure");
 
  460                            $obj->mMinMeasure = $tempVal;
 
  470                        $c_obj[
'_SeqObjective'] = $obj;
 
  471                        array_push($objectives, $c_obj);
 
  475            $ioAct->setObjectives($objectives);
 
  483            $objectives = $ioAct->mObjectives;
 
  484            $children = $iNode->childNodes;
 
  485            for (
$i = 0; 
$i < $children->length; 
$i++) {
 
  486                $curNode = $children->item(
$i);
 
  487                if ($curNode->nodeType == XML_ELEMENT_NODE) {
 
  488                    if ($curNode->localName == 
"objective") {
 
  490                        $adlseqobjid = preg_replace(
'/(%20)+/', 
' ', trim($curNode->getAttribute(
"objectiveID")));
 
  494                        for ($j = 0; $j < count($objectives); $j++) {
 
  495                            $seqobj = $objectives[$j][
'_SeqObjective'];
 
  496                            if ($seqobj->mObjID == $adlseqobjid) {
 
  497                                $curseqobj = $seqobj;
 
  498                                $curseqobjindex = $j;
 
  504                        if ($curseqobj != 
null) {
 
  507                            $seqobj = $curseqobj;
 
  508                            $objectives[$curseqobjindex][
'_SeqObjective'] = $seqobj;
 
  515            $ioAct->setObjectives($objectives);
 
  521            if (count($curseqobj->mMaps) == 
null) {
 
  522                $curseqobj->mMaps = array();
 
  524            $maps = $curseqobj->mMaps;
 
  526            $children = $iNode->childNodes;
 
  527            for (
$i = 0; 
$i < $children->length; 
$i++) {
 
  528                $curNode = $children->item(
$i);
 
  529                if ($curNode->nodeType == XML_ELEMENT_NODE) {
 
  530                    if ($curNode->localName == 
"mapInfo") {
 
  532                        $curadltargetobjid = preg_replace(
'/(%20)+/', 
' ', trim($curNode->getAttribute(
"targetObjectiveID")));
 
  534                        $matchingmapindex = -1;
 
  535                        for ($j = 0; $j < count($maps); $j++) {
 
  536                            if ($maps[$j][
'_SeqObjectiveMap']->mGlobalObjID == $curadltargetobjid) {
 
  537                                $map = $maps[$j][
'_SeqObjectiveMap'];
 
  538                                $matchingmapindex = $j;
 
  544                        if ($matchingmapindex > -1) {
 
  545                            $c_map[
'_SeqObjectiveMap'] = 
$map;
 
  546                            $maps[$matchingmapindex] = $c_map;
 
  548                            $c_map[
'_SeqObjectiveMap'] = 
$map;
 
  549                            array_push($maps, $c_map);
 
  554            $curseqobj->mMaps = $maps;
 
  560            if (
$map->mGlobalObjID == 
null) {
 
  561                $map->mGlobalObjID = preg_replace(
'/(%20)+/', 
' ', trim($iNode->getAttribute(
"targetObjectiveID")));
 
  564            $tempVal = $iNode->getAttribute(
"readRawScore");
 
  569            $tempVal = $iNode->getAttribute(
"readMinScore");
 
  574            $tempVal = $iNode->getAttribute(
"readMaxScore");
 
  579            $tempVal = $iNode->getAttribute(
"readCompletionStatus");
 
  584            $tempVal = $iNode->getAttribute(
"readProgressMeasure");
 
  589            $tempVal = $iNode->getAttribute(
"writeRawScore");
 
  594            $tempVal = $iNode->getAttribute(
"writeMinScore");
 
  599            $tempVal = $iNode->getAttribute(
"writeMaxScore");
 
  604            $tempVal = $iNode->getAttribute(
"writeCompletionStatus");
 
  609            $tempVal = $iNode->getAttribute(
"writeProgressMeasure");
 
  621            $children = $iNode->childNodes;
 
  622            for (
$i = 0; 
$i < $children->length; 
$i++) {
 
  623                $curNode = $children->item(
$i);
 
  624                if ($curNode->nodeType == XML_ELEMENT_NODE) {
 
  625                    if ($curNode->localName == 
"mapInfo") {
 
  629                        $tempVal = preg_replace(
'/(%20)+/', 
' ', trim($curNode->getAttribute(
"targetObjectiveID")));
 
  631                            $map->mGlobalObjID = $tempVal;
 
  635                        $tempVal = $curNode->getAttribute(
"readSatisfiedStatus");
 
  641                        $tempVal = $curNode->getAttribute(
"readNormalizedMeasure");
 
  647                        $tempVal = $curNode->getAttribute(
"writeSatisfiedStatus");
 
  653                        $tempVal = $curNode->getAttribute(
"writeNormalizedMeasure");
 
  658                        $c_map[
'_SeqObjectiveMap'] = 
$map;
 
  659                        array_push($maps, $c_map);
 
  663            if (count($maps) == 
null) {
 
  673            $rollupRules = array();
 
  676            $tempVal = $iNode->getAttribute(
"rollupObjectiveSatisfied");
 
  678                $ioAct->setIsObjRolledUp(self::convert_to_bool($tempVal));
 
  682            $tempVal = $iNode->getAttribute(
"objectiveMeasureWeight");
 
  684                $ioAct->setObjMeasureWeight($tempVal);
 
  687            $tempVal = $iNode->getAttribute(
"rollupProgressCompletion");
 
  689                $ioAct->setIsProgressRolledUp(self::convert_to_bool($tempVal));
 
  691            $children = $iNode->childNodes;
 
  692            for (
$i = 0; 
$i < $children->length; 
$i++) {
 
  693                $curNode = $children->item(
$i);
 
  694                if ($curNode->nodeType == XML_ELEMENT_NODE) {
 
  695                    if ($curNode->localName == 
"rollupRule") {
 
  699                        $tempVal = $curNode->getAttribute(
"childActivitySet");
 
  701                            $rule->mChildActivitySet = $tempVal;
 
  704                        $tempVal = $curNode->getAttribute(
"minimumCount");
 
  706                            $rule->mMinCount = $tempVal;
 
  710                        $tempVal = $curNode->getAttribute(
"minimumPercent");
 
  712                            $rule->mMinPercent = $tempVal;
 
  715                        $conditions = array();
 
  716                        $ruleInfo = $curNode->childNodes;
 
  717                        for ($j = 0; $j < $ruleInfo->length; $j++) {
 
  718                            $curRule = $ruleInfo->item($j);
 
  720                            if ($curRule->nodeType == XML_ELEMENT_NODE) {
 
  721                                if ($curRule->localName == 
"rollupConditions") {
 
  722                                    $tempVal = $curRule->getAttribute(
"conditionCombination");
 
  724                                        $rule->mConditions[
'_SeqConditionSet']->mCombination = $tempVal;
 
  728                                    $conds = $curRule->childNodes;
 
  729                                    for ($k = 0; $k < $conds->length; $k++) {
 
  730                                        $con = $conds->item($k);
 
  731                                        if ($con->nodeType == XML_ELEMENT_NODE) {
 
  732                                            if ($con->localName == 
"rollupCondition") {
 
  735                                                $tempVal = $con->getAttribute(
"condition");
 
  737                                                    $cond->mCondition = $tempVal;
 
  740                                                $tempVal = $con->getAttribute(
"operator");
 
  742                                                    if ($tempVal == 
'not') {
 
  749                                                $c_cond[
'_SeqCondition'] = $cond;
 
  750                                                array_push($conditions, $c_cond);
 
  754                                } elseif ($curRule->localName == 
"rollupAction") {
 
  755                                    $tempVal = $curRule->getAttribute(
"action");
 
  757                                        $rule->setRollupAction($tempVal);
 
  763                        $rule->mConditions[
'_SeqConditionSet']->mConditions = $conditions;
 
  767                        $c_rule[
'_SeqRollupRule'] = 
$rule;
 
  768                        array_push($rollupRules, $c_rule);
 
  773            if ($rollupRules != 
null) {
 
  777                $c_rules[
'_SeqRollupRuleset'] = $rules;
 
  778                $ioAct->setRollupRules($c_rules);
 
  792            $exitRules = array();
 
  793            $postRules = array();
 
  796            $children = $iNode->childNodes;
 
  799            for (
$i = 0; 
$i < $children->length; 
$i++) {
 
  800                $curNode = $children->item(
$i);
 
  801                if ($curNode->nodeType == XML_ELEMENT_NODE) {
 
  802                    if ($curNode->localName == 
"preConditionRule" || $curNode->localName == 
"exitConditionRule" || $curNode->localName == 
"postConditionRule") {
 
  804                        $ruleInfo = $curNode->childNodes;
 
  805                        for ($j = 0; $j < $ruleInfo->length; $j++) {
 
  806                            $curRule = $ruleInfo->item($j);
 
  808                            if ($curRule->nodeType == XML_ELEMENT_NODE) {
 
  809                                if ($curRule->localName == 
"ruleConditions") {
 
  811                                } elseif ($curRule->localName == 
"ruleAction") {
 
  812                                    $tempVal = $curRule->getAttribute(
"action");
 
  814                                        $rule->mAction = $tempVal;
 
  819                        if (
$rule->mConditions != 
null && 
$rule->mAction != 
null) {
 
  821                            if ($curNode->localName == 
"preConditionRule") {
 
  824                                $c_rule[
'_SeqRule'] = 
$rule;
 
  825                                array_push($preRules, $c_rule);
 
  827                            if ($curNode->localName == 
"exitConditionRule") {
 
  830                                $c_rule[
'_SeqRule'] = 
$rule;
 
  831                                array_push($exitRules, $c_rule);
 
  833                            if ($curNode->localName == 
"postConditionRule") {
 
  836                                $c_rule[
'_SeqRule'] = 
$rule;
 
  837                                array_push($postRules, $c_rule);
 
  844            if (count($preRules) > 0) {
 
  847                $c_rules[
'_SeqRuleset'] = $rules;
 
  848                $ioAct->setPreSeqRules($c_rules);
 
  851            if (count($exitRules) > 0) {
 
  854                $c_rules[
'_SeqRuleset'] = $rules;
 
  855                $ioAct->setExitSeqRules($c_rules);
 
  857            if (count($postRules) > 0) {
 
  860                $c_rules[
'_SeqRuleset'] = $rules;
 
  861                $ioAct->setPostSeqRules($c_rules);
 
  873            $conditions = array();
 
  874            $tempVal = $iNode->getAttribute(
"conditionCombination");
 
  876                $condSet->mCombination = $tempVal;
 
  880            $condInfo = $iNode->childNodes;
 
  881            for (
$i = 0; 
$i < $condInfo->length; 
$i++) {
 
  882                $curCond = $condInfo->item(
$i);
 
  883                if ($curCond->nodeType == XML_ELEMENT_NODE) {
 
  884                    if ($curCond->localName == 
"ruleCondition") {
 
  888                        $tempVal = $curCond->getAttribute(
"condition");
 
  890                            $cond->mCondition = $tempVal;
 
  894                        $tempVal = preg_replace(
'/(%20)+/', 
' ', trim($curCond->getAttribute(
"referencedObjective")));
 
  896                            $cond->mObjID = $tempVal;
 
  900                        $tempVal = $curCond->getAttribute(
"measureThreshold");
 
  902                            $cond->mThreshold = $tempVal;
 
  906                        $tempVal = $curCond->getAttribute(
"operator");
 
  908                            if ($tempVal == 
'not') {
 
  916                        $c_cond[
'_SeqCondition'] = $cond;
 
  917                        array_push($conditions, $c_cond);
 
  922            if (count($conditions) > 0) {
 
  923                $condSet->mConditions = $conditions;
 
  925                $condSet->mConditions = 
null;
 
  928            $c_condSet[
'_SeqConditionSet'] = $condSet;
 
  938            $children = $iNode->childNodes;
 
  941            for (
$i = 0; 
$i < $children->length; 
$i++) {
 
  942                $curNode = $children->item(
$i);
 
  943                if ($curNode->nodeType == XML_ELEMENT_NODE) {
 
  944                    if ($curNode->localName == 
"auxiliaryResource") {
 
  949                        $tempVal = $curNode->getAttribute(
"purpose");
 
  951                            $res->mType = $tempVal;
 
  954                        $tempVal = preg_replace(
'/(%20)+/', 
' ', trim($curNode->getAttribute(
"auxiliaryResourceID")));
 
  956                            $res->mResourceID = $tempVal;
 
  958                        array_push($auxRes, 
$res);
 
  963            $c_auxRes[
'_ADLAuxiliaryResource'] = $auxRes;
 
  964            $ioAct->setAuxResources($c_auxRes);
 
  972            if (strtoupper($string) == 
"FALSE") {
 
  986            if ($iNode != 
null && $iElement != 
null) {
 
  987                $children = $iNode->childNodes;
 
  988                for (
$i = 0; 
$i < $children->length; 
$i++) {
 
  989                    $curNode = $children->item(
$i);
 
  990                    if (($curNode->nodeType == XML_ELEMENT_NODE)) {
 
  991                        if ($curNode->localName == $iElement) {
 
  996                if ($curNode != 
null) {
 
  997                    $comp = $curNode->localName;
 
  999                        if ($comp != $iElement) {
 
 1011            if ($curNode != 
null) {
 
 1012                $children = $curNode->childNodes;
 
 1013                if ($children != 
null) {
 
 1014                    for (
$i = 0; 
$i < $children->length; 
$i++) {
 
 1015                        $curNode = $children->item(
$i);
 
 1017                        if (($curNode->nodeType == XML_TEXT_NODE) || ($curNode->nodeType == XML_CDATA_SECTION_NODE)) {
 
 1018                            $value = $value . $curNode->nodeValue;
 
An exception for terminatinating execution or to throw for unit testing.
static getADLSEQObjectives($iNode, $ioAct)
static getObjectiveMaps($iNode)
buildNode($node, $seq, $doc)
static getSequencingRules($iNode, $ioAct)
static getADLSeqMaps($iNode, $curseqobj)
static getAuxResources($iNode, $ioAct)
extractSeqInfo($iNode, $ioAct)
static fillinADLSeqMaps($iNode, $map)
static convert_to_bool($string)
static getObjectives($iNode, $ioAct)
static extractSeqRuleConditions($iNode)
static getRollupRules($iNode, $ioAct)
static lookupElement($iNode, $iElement)
if($source===NULL) $organizations
foreach($_POST as $key=> $value) $res