SeqTreeBuilder.php

Go to the documentation of this file.

<?php
/*
    +-----------------------------------------------------------------------------+
    | ILIAS open source                                                           |
    +-----------------------------------------------------------------------------+
    | Copyright (c) 1998-2007 ILIAS open source, University of Cologne            |
    |                                                                             |
    | This program is free software; you can redistribute it and/or               |
    | modify it under the terms of the GNU General Public License                 |
    | as published by the Free Software Foundation; either version 2              |
    | of the License, or (at your option) any later version.                      |
    |                                                                             |
    | This program is distributed in the hope that it will be useful,             |
    | but WITHOUT ANY WARRANTY; without even the implied warranty of              |
    | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               |
    | GNU General Public License for more details.                                |
    |                                                                             |
    | You should have received a copy of the GNU General Public License           |
    | along with this program; if not, write to the Free Software                 |
    | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. |
    +-----------------------------------------------------------------------------+
*/
/*
    PHP port of several ADL-sources
    @author Hendrik Holtmann <holtmann@mac.com>
 
    This .php file is GPL licensed (see above) but based on
    Sourcecode by ADL Co-Lab, which is licensed as:
 
    Advanced Distributed Learning Co-Laboratory (ADL Co-Lab) Hub grants you
    ("Licensee") a non-exclusive, royalty free, license to use, modify and
    redistribute this software in source and binary code form, provided that
    i) this copyright notice and license appear on all copies of the software;
    and ii) Licensee does not utilize the software in a manner which is
    disparaging to ADL Co-Lab Hub.
 
    This software is provided "AS IS," without a warranty of any kind.  ALL
    EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
    ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
    OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.  ADL Co-Lab Hub AND ITS LICENSORS
    SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF
    USING, MODIFYING OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES.  IN NO
    EVENT WILL ADL Co-Lab Hub OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE,
    PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
    INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE
    THEORY OF LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE
    SOFTWARE, EVEN IF ADL Co-Lab Hub HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
    DAMAGES.
*/
 
    require_once("SeqActivity.php");
    
    require_once("SeqRule.php");
    require_once("SeqRuleset.php");
    
    require_once("SeqCondition.php");
    require_once("SeqConditionSet.php");
    
    require_once("SeqObjective.php");
    require_once("SeqObjectiveMap.php");
    
    require_once("SeqRollupRule.php");
    require_once("SeqRollupRuleset.php");
    
    require_once("ADLAuxiliaryResource.php");
 
    class SeqTreeBuilder
    {
        public function buildNodeSeqTree($file)
        {
            $doc = new DomDocument();
            $doc->load($file);
            $organizations = $doc->getElementsByTagName("organizations");
        
            //lookup default organization id
            $default = preg_replace('/(%20)+/', ' ', trim($organizations->item(0)->getAttribute("default")));
        
            //get all organization nodes
            $organization = $doc->getElementsByTagName("organization");
        
            //lookup the default organization
            foreach ($organization as $element) {
                if (preg_replace('/(%20)+/', ' ', trim($element->getAttribute("identifier"))) == $default) {
                    $default_organization = $element;
                }
            }
        
            //read seqCollection
            $seqCollection = $doc->getElementsByTagName("sequencingCollection")->item(0);
        
            $root = $this->buildNode($default_organization, $seqCollection, $doc);
        
            //return no data please check
            $objectivesGlobalToSystem = $default_organization->getAttributeNS("http://www.adlnet.org/xsd/adlseq_v1p3", "objectivesGlobalToSystem");
    
            $org = preg_replace('/(%20)+/', ' ', trim($default_organization->getAttribute("identifier")));
        
            //default true
            $globaltosystem = 1;
        
            if ($objectivesGlobalToSystem == "false") {
                $globaltosystem = 0;
            }
        
            //return no data please check
            $dataGlobalToSystem = $default_organization->getAttributeNS("http://www.adlnet.org/xsd/adlcp_v1p3", "sharedDataGlobalToSystem");
    
            //default true
            $dataglobaltosystem = 1;
        
            if ($dataGlobalToSystem == "false") {
                $dataglobaltosystem = 0;
            }
                
            //assign SeqActivity to top node
            $c_root['_SeqActivity'] = $root;
                
            $ret['global'] = $globaltosystem;
            $ret['dataglobal'] = $dataglobaltosystem;
            $ret['tree'] = $c_root;
        
            return $ret;
        }
      
      
      
        private function buildNode($node, $seq, $doc)
        {
 
        //create a new activity object
            $act = new SeqActivity();
                
            //set various attributes, if existent
            $act->setID(preg_replace('/(%20)+/', ' ', trim($node->getAttribute("identifier"))));
        
            $tempVal = preg_replace('/(%20)+/', ' ', trim($node->getAttribute("identifierref")));
            if ($tempVal) {
                $act->setResourceID($tempVal);
            }
        
            $tempVal = $node->getAttribute("isvisible");
      
            if ($tempVal) {
                $act->setIsVisible(self::convert_to_bool($tempVal));
            }
         
        
        
            //Proceed nested items
            $children = $node->childNodes;
        
            for ($i = 0; $i < $children->length; $i++) {
                $curNode = $children->item($i);
                //elements only
            
                if ($curNode->nodeType == XML_ELEMENT_NODE) {
                    //only items are nested
                    if ($curNode->localName == "item") {
                        //init;
                        $c_nestedAct = null;
                        $nestedAct = new SeqActivity();
                        $nestedAct = $this->buildNode($curNode, $seq, $doc);
                        if ($nestedAct != null) {
                            $act->AddChild($nestedAct);
                        }
                    } elseif ($curNode->localName == "title") {
                        $act->setTitle($this->lookupElement($curNode, null));
                    } elseif ($curNode->localName == "completionThreshold") {
                        $tempVal = $curNode->getAttribute("minProgressMeasure");
                     
                        if ($tempVal) {
                            $act->setCompletionThreshold($tempVal);
                        } elseif ($curNode->nodeValue != null && $curNode->nodeValue != '') {
                            $act->setCompletionThreshold($curNode->nodeValue);
                        }
        
                        $tempVal = $curNode->getAttribute("progressWeight");
                     
                        if ($tempVal) {
                            $act->setProgressWeight($tempVal);
                        }
                        $tempVal = $curNode->getAttribute("completedByMeasure");
                 
                        if ($tempVal) {
                            $act->setCompletedByMeasure(self::convert_to_bool($tempVal));
                        }
                    } elseif ($curNode->localName == "sequencing") {
                        $seqInfo = $curNode;
                        //get IDRef
                        $tempVal = preg_replace('/(%20)+/', ' ', trim($curNode->getAttribute("IDRef")));
                        //only execute for referenced sequencing parts
                        if ($tempVal) {
                            //init seqGlobal
                            $seqGlobal = null;
                        
                            //get all sequencing nodes in collections
                            $sequencing = $seq->getElementsByTagName("sequencing");
      
                            //lookup the matching sequencing element
                            foreach ($sequencing as $element) {
                                if (preg_replace('/(%20)+/', ' ', trim($element->getAttribute("ID"))) == $tempVal) {
                                    $seqGlobal = $element;
                                }
                            }
                        
                            //clone the global node
                            $seqInfo = $seqGlobal->cloneNode(true);
                        
                            //back to the local node
                            $seqChildren = $curNode->childNodes;
                            for ($j = 0; $j < $seqChildren->length; $j++) {
                                //process local nodes
                                $curChild = $seqChildren->item($j);
                                if ($curChild->nodeType == XML_ELEMENT_NODE) {
                                    //echo "\nFound Sequencing Element Node".$curChild->localName;
                                    //add local to global sequencing info
                                    $seqInfo->appendChild($curChild);
                                }
                            }
                        }
                        //extract the sequencing info, if we have one
                        //avoid working with
                        $act = $this->extractSeqInfo($seqInfo, $act);
                    }
                }
            
        
         
                $item = $children->item($i)->nodeValue;
            }
            //add class
            //$c_act['_SeqActivity']=$act;
            return $act;
        }
      
      
        private function extractSeqInfo($iNode, $ioAct)
        {
            //set sequencing information
            $children = $iNode->childNodes;
            for ($i = 0; $i < $children->length; $i++) {
                $curNode = $children->item($i);
                if ($curNode->nodeType == XML_ELEMENT_NODE) {
                    if ($curNode->localName == "controlMode") {
                        //look for choice
                        $tempVal = $curNode->getAttribute("choice");
                        if ($tempVal) {
                            $ioAct->setControlModeChoice(self::convert_to_bool($tempVal));
                        }
                        //look for choiceExit
                        $tempVal = $curNode->getAttribute("choiceExit");
                        if ($tempVal) {
                            $ioAct->setControlModeChoiceExit(self::convert_to_bool($tempVal));
                        }
                    
                        //look for flow
                        $tempVal = $curNode->getAttribute("flow");
                        if ($tempVal) {
                            $ioAct->setControlModeFlow(self::convert_to_bool($tempVal));
                        }
                    
                        // Look for 'forwardOnly'
                        $tempVal = $curNode->getAttribute("forwardOnly");
                        if ($tempVal) {
                            $ioAct->setControlForwardOnly(self::convert_to_bool($tempVal));
                        }
                    
                        // Look for 'useCurrentAttemptObjectiveInfo'
                        $tempVal = $curNode->getAttribute("useCurrentAttemptObjectiveInfo");
                        if ($tempVal) {
                            $ioAct->setUseCurObjective(self::convert_to_bool($tempVal));
                        }
                    
                        // Look for 'useCurrentAttemptProgressInfo'
                        $tempVal = $curNode->getAttribute("useCurrentAttemptProgressInfo");
                        if ($tempVal) {
                            $ioAct->setUseCurProgress(self::convert_to_bool($tempVal));
                        }
                    } elseif ($curNode->localName == "sequencingRules") {
                        $ioAct = $this->getSequencingRules($curNode, $ioAct);
                    } elseif ($curNode->localName == "limitConditions") {
                        // Look for 'useCurrentAttemptObjectiveInfo'
                        $tempVal = $curNode->getAttribute("attemptLimit");
                        if ($tempVal) {
                            $ioAct->setAttemptLimit($tempVal);
                        }
                
                        // Look for 'attemptAbsoluteDurationLimit'
                        $tempVal = $curNode->getAttribute("attemptAbsoluteDurationLimit");
                        if ($tempVal) {
                            $ioAct->setAttemptAbDur($tempVal);
                        }
            
                        // Look for 'attemptExperiencedDurationLimit'
                        $tempVal = $curNode->getAttribute("attemptExperiencedDurationLimit");
                        if ($tempVal) {
                            $ioAct->setAttemptExDur($tempVal);
                        }
    
                        // Look for 'activityAbsoluteDurationLimit'
                        $tempVal = $curNode->getAttribute("activityAbsoluteDurationLimit");
                        if ($tempVal) {
                            $ioAct->setActivityAbDur($tempVal);
                        }
                   
                        // Look for 'activityExperiencedDurationLimit'
                        $tempVal = $curNode->getAttribute("activityExperiencedDurationLimit");
                        if ($tempVal) {
                            $ioAct->setActivityExDur($tempVal);
                        }
            
                        // Look for 'beginTimeLimit'
                        $tempVal = $curNode->getAttribute("beginTimeLimit");
                        if ($tempVal) {
                            $ioAct->setBeginTimeLimit($tempVal);
                        }
                    
                        // Look for 'endTimeLimit'
                        $tempVal = $curNode->getAttribute("endTimeLimit");
                        if ($tempVal) {
                            $ioAct->setEndTimeLimit($tempVal);
                        }
                    } elseif ($curNode->localName == "auxiliaryResources") {
                        $ioAct = self::getAuxResources($curNode, $ioAct);
                    } elseif ($curNode->localName == "rollupRules") {
                        $ioAct = self::getRollupRules($curNode, $ioAct);
                    } elseif ($curNode->localName == "objectives" && $curNode->namespaceURI == "http://www.imsglobal.org/xsd/imsss") {
                        $ioAct = self::getObjectives($curNode, $ioAct);
                    } elseif ($curNode->localName == "objectives" && $curNode->namespaceURI == "http://www.adlnet.org/xsd/adlseq_v1p3") {
                        $ioAct = self::getADLSEQObjectives($curNode, $ioAct);
                    } elseif ($curNode->localName == "randomizationControls") {
                    
                    // Look for 'randomizationTiming'
                        $tempVal = $curNode->getAttribute("randomizationTiming");
                        if ($tempVal) {
                            $ioAct->setRandomTiming($tempVal);
                        }
                    
                        // Look for 'selectCount'
                        $tempVal = $curNode->getAttribute("selectCount");
                        if ($tempVal) {
                            $ioAct->setSelectCount($tempVal);
                        }
                    
                        // Look for 'reorderChildren'
                        $tempVal = $curNode->getAttribute("reorderChildren");
                        if ($tempVal) {
                            $ioAct->setReorderChildren(self::convert_to_bool($tempVal));
                        }
                    
                        // Look for 'selectionTiming'
                        $tempVal = $curNode->getAttribute("selectionTiming");
                        if ($tempVal) {
                            $ioAct->setSelectionTiming($tempVal);
                        }
                    } elseif ($curNode->localName == "deliveryControls") {
                    
                    // Look for 'tracked'
                        $tempVal = $curNode->getAttribute("tracked");
                        if ($tempVal) {
                            $ioAct->setIsTracked(self::convert_to_bool($tempVal));
                        }
                      
                        // Look for 'completionSetByContent'
                        $tempVal = $curNode->getAttribute("completionSetByContent");
                        if ($tempVal) {
                            $ioAct->setSetCompletion(self::convert_to_bool($tempVal));
                        }
                  
                        // Look for 'objectiveSetByContent'
                        $tempVal = $curNode->getAttribute("objectiveSetByContent");
                        if ($tempVal) {
                            $ioAct->setSetObjective(self::convert_to_bool($tempVal));
                        }
                    } elseif ($curNode->localName == "constrainedChoiceConsiderations") {
                    
                    // Look for 'preventActivation'
                        $tempVal = $curNode->getAttribute("preventActivation");
                        if ($tempVal) {
                            $ioAct->setPreventActivation(self::convert_to_bool($tempVal));
                        }
                    
                        // Look for 'constrainChoice'
                        $tempVal = $curNode->getAttribute("constrainChoice");
                        if ($tempVal) {
                            $ioAct->setConstrainChoice(self::convert_to_bool($tempVal));
                        }
                    } elseif ($curNode->localName == "rollupConsiderations") {
                
                    // Look for 'requiredForSatisfied'
                        $tempVal = $curNode->getAttribute("requiredForSatisfied");
                        if ($tempVal) {
                            $ioAct->setRequiredForSatisfied($tempVal);
                        }
                    
                        // Look for 'requiredForNotSatisfied'
                        $tempVal = $curNode->getAttribute("requiredForNotSatisfied");
                        if ($tempVal) {
                            $ioAct->setRequiredForNotSatisfied($tempVal);
                        }
                    
                        // Look for 'requiredForCompleted'
                        $tempVal = $curNode->getAttribute("requiredForCompleted");
                        if ($tempVal) {
                            $ioAct->setRequiredForCompleted($tempVal);
                        }
                    
                        // Look for 'requiredForIncomplete'
                        $tempVal = $curNode->getAttribute("requiredForIncomplete");
                        if ($tempVal) {
                            $ioAct->setRequiredForIncomplete($tempVal);
                        }
                
                        // Look for 'measureSatisfactionIfActive'
                        $tempVal = $curNode->getAttribute("measureSatisfactionIfActive");
                        if ($tempVal) {
                            $ioAct->setSatisfactionIfActive(self::convert_to_bool($tempVal));
                        }
                    }
                }  //end note-type check
            } //end for-loop
         
            return $ioAct;
        }
    
    
        public static function getObjectives($iNode, $ioAct)
        {
            global $DIC;
            $ilLog = $DIC['ilLog'];
        
        
            $ok = true;
            $tempVal = null;
            $objectives = array();
            $children = $iNode->childNodes;
            for ($i = 0; $i < $children->length; $i++) {
                $curNode = $children->item($i);
                if ($curNode->nodeType == XML_ELEMENT_NODE) {
                    if ($curNode->localName == "primaryObjective" || $curNode->localName == "objective") {
                        $obj = new SeqObjective();
                        if ($curNode->localName == "primaryObjective") {
                            $obj->mContributesToRollup = true;
                        }
                    
                        // Look for 'objectiveID'
                        $tempVal = preg_replace('/(%20)+/', ' ', trim($curNode->getAttribute("objectiveID")));
                        if ($tempVal) {
                            $obj->mObjID = $tempVal;
                        }
 
                        // Look for 'satisfiedByMeasure'
                        $tempVal = $curNode->getAttribute("satisfiedByMeasure");
                        if ($tempVal) {
                            $obj->mSatisfiedByMeasure = self::convert_to_bool($tempVal);
                        }
                        // Look for 'minNormalizedMeasure'
                        $tempVal = self::lookupElement($curNode, "minNormalizedMeasure");
                        if ($tempVal) {
                            $obj->mMinMeasure = $tempVal;
                        }
                
                        //get ObjectiveMaps
                        $maps = self::getObjectiveMaps($curNode);
                        if ($maps != null) {
                            $obj->mMaps = $maps;
                        }
                        //$obj->mContributesToRollup = true;
                        //add class
                        $c_obj['_SeqObjective'] = $obj;
                        array_push($objectives, $c_obj);
                    }
                }
            }
            $ioAct->setObjectives($objectives);
            return $ioAct;
        }
    
        public static function getADLSEQObjectives($iNode, $ioAct)
        {
            global $DIC;
            $ilLog = $DIC['ilLog'];
            $objectives = $ioAct->mObjectives;
            $children = $iNode->childNodes;
            for ($i = 0; $i < $children->length; $i++) {
                $curNode = $children->item($i);
                if ($curNode->nodeType == XML_ELEMENT_NODE) {
                    if ($curNode->localName == "objective") {
                        // get the objectiveID
                        $adlseqobjid = preg_replace('/(%20)+/', ' ', trim($curNode->getAttribute("objectiveID")));
                    
                        // find the imsss objective with the same objectiveID
                        $curseqobj = null;
                        for ($j = 0; $j < count($objectives); $j++) {
                            $seqobj = $objectives[$j]['_SeqObjective'];
                            if ($seqobj->mObjID == $adlseqobjid) {
                                $curseqobj = $seqobj;
                                $curseqobjindex = $j;
                                break;
                            }
                        }
                    
                        // if there's a current seq then let's add the maps
                        if ($curseqobj != null) {
                            //  for each adlseq map info populate that mMaps with map info in the adlseq objective
                            $curseqobj = self::getADLSeqMaps($curNode, $curseqobj);
                            $seqobj = $curseqobj;
                            $objectives[$curseqobjindex]['_SeqObjective'] = $seqobj;
                        }
                    }
                }
            }
            // before i leave what do i have to duplicate in SeqActivity or some other class?
            // prolly just
            $ioAct->setObjectives($objectives);
            return $ioAct;
        }
    
        public static function getADLSeqMaps($iNode, $curseqobj)
        {
            if (count($curseqobj->mMaps) == null) {
                $curseqobj->mMaps = array();
            }
            $maps = $curseqobj->mMaps;
 
            $children = $iNode->childNodes;
            for ($i = 0; $i < $children->length; $i++) {
                $curNode = $children->item($i);
                if ($curNode->nodeType == XML_ELEMENT_NODE) {
                    if ($curNode->localName == "mapInfo") {
                        $map = new SeqObjectiveMap();
                        $curadltargetobjid = preg_replace('/(%20)+/', ' ', trim($curNode->getAttribute("targetObjectiveID")));
                        // if the adl map target id matches an imsssssss one, then add to the imsssss one
                        $matchingmapindex = -1;
                        for ($j = 0; $j < count($maps); $j++) {
                            if ($maps[$j]['_SeqObjectiveMap']->mGlobalObjID == $curadltargetobjid) {
                                $map = $maps[$j]['_SeqObjectiveMap'];
                                $matchingmapindex = $j;
                            }
                        }
                        // tom: if default access is dependent on map existence then this will need to know if an imsss:mapInfo existed
                        $map = self::fillinADLSeqMaps($curNode, $map);
                    
                        if ($matchingmapindex > -1) {
                            $c_map['_SeqObjectiveMap'] = $map;
                            $maps[$matchingmapindex] = $c_map;
                        } else {
                            $c_map['_SeqObjectiveMap'] = $map;
                            array_push($maps, $c_map);
                        }
                    }
                }
            }
            $curseqobj->mMaps = $maps;
            return $curseqobj;
        }
    
        public static function fillinADLSeqMaps($iNode, $map)
        {
            if ($map->mGlobalObjID == null) {
                $map->mGlobalObjID = preg_replace('/(%20)+/', ' ', trim($iNode->getAttribute("targetObjectiveID")));
            }
 
            $tempVal = $iNode->getAttribute("readRawScore");
            if ($tempVal) {
                $map->mReadRawScore = self::convert_to_bool($tempVal);
            }
 
            $tempVal = $iNode->getAttribute("readMinScore");
            if ($tempVal) {
                $map->mReadMinScore = self::convert_to_bool($tempVal);
            }
        
            $tempVal = $iNode->getAttribute("readMaxScore");
            if ($tempVal) {
                $map->mReadMaxScore = self::convert_to_bool($tempVal);
            }
        
            $tempVal = $iNode->getAttribute("readCompletionStatus");
            if ($tempVal) {
                $map->mReadCompletionStatus = self::convert_to_bool($tempVal);
            }
        
            $tempVal = $iNode->getAttribute("readProgressMeasure");
            if ($tempVal) {
                $map->mReadProgressMeasure = self::convert_to_bool($tempVal);
            }
        
            $tempVal = $iNode->getAttribute("writeRawScore");
            if ($tempVal) {
                $map->mWriteRawScore = self::convert_to_bool($tempVal);
            }
 
            $tempVal = $iNode->getAttribute("writeMinScore");
            if ($tempVal) {
                $map->mWriteMinScore = self::convert_to_bool($tempVal);
            }
        
            $tempVal = $iNode->getAttribute("writeMaxScore");
            if ($tempVal) {
                $map->mWriteMaxScore = self::convert_to_bool($tempVal);
            }
        
            $tempVal = $iNode->getAttribute("writeCompletionStatus");
            if ($tempVal) {
                $map->mWriteCompletionStatus = self::convert_to_bool($tempVal);
            }
        
            $tempVal = $iNode->getAttribute("writeProgressMeasure");
            if ($tempVal) {
                $map->mWriteProgressMeasure = self::convert_to_bool($tempVal);
            }
        
            return $map;
        }
    
        public static function getObjectiveMaps($iNode)
        {
            $tempVal = null;
            $maps = array();
            $children = $iNode->childNodes;
            for ($i = 0; $i < $children->length; $i++) {
                $curNode = $children->item($i);
                if ($curNode->nodeType == XML_ELEMENT_NODE) {
                    if ($curNode->localName == "mapInfo") {
                        $map = new SeqObjectiveMap();
                    
                        // Look for 'targetObjectiveID'
                        $tempVal = preg_replace('/(%20)+/', ' ', trim($curNode->getAttribute("targetObjectiveID")));
                        if ($tempVal) {
                            $map->mGlobalObjID = $tempVal;
                        }
        
                        // Look for 'readSatisfiedStatus'
                        $tempVal = $curNode->getAttribute("readSatisfiedStatus");
                        if ($tempVal) {
                            $map->mReadStatus = self::convert_to_bool($tempVal);
                        }
        
                        // Look for 'readNormalizedMeasure'
                        $tempVal = $curNode->getAttribute("readNormalizedMeasure");
                        if ($tempVal) {
                            $map->mReadMeasure = self::convert_to_bool($tempVal);
                        }
            
                        // Look for 'writeSatisfiedStatus'
                        $tempVal = $curNode->getAttribute("writeSatisfiedStatus");
                        if ($tempVal) {
                            $map->mWriteStatus = self::convert_to_bool($tempVal);
                        }
            
                        // Look for 'writeNormalizedMeasure'
                        $tempVal = $curNode->getAttribute("writeNormalizedMeasure");
                        if ($tempVal) {
                            $map->mWriteMeasure = self::convert_to_bool($tempVal);
                        }
                        //add class
                        $c_map['_SeqObjectiveMap'] = $map;
                        array_push($maps, $c_map);
                    }
                }
            }
            if (count($maps) == null) {
                $maps = null;
            }
            return $maps;
        }
    
        public static function getRollupRules($iNode, $ioAct)
        {
            $ok = true;
            $tempVal = null;
            $rollupRules = array();
        
            // Look for 'rollupObjectiveSatisfied'
            $tempVal = $iNode->getAttribute("rollupObjectiveSatisfied");
            if ($tempVal) {
                $ioAct->setIsObjRolledUp(self::convert_to_bool($tempVal));
            }
        
            // Look for 'objectiveMeasureWeight'
            $tempVal = $iNode->getAttribute("objectiveMeasureWeight");
            if ($tempVal) {
                $ioAct->setObjMeasureWeight($tempVal);
            }
            // Look for 'rollupProgressCompletion'
            $tempVal = $iNode->getAttribute("rollupProgressCompletion");
            if ($tempVal) {
                $ioAct->setIsProgressRolledUp(self::convert_to_bool($tempVal));
            }
            $children = $iNode->childNodes;
            for ($i = 0; $i < $children->length; $i++) {
                $curNode = $children->item($i);
                if ($curNode->nodeType == XML_ELEMENT_NODE) {
                    if ($curNode->localName == "rollupRule") {
                        $rule = new SeqRollupRule();
            
                        // Look for 'childActivitySet'
                        $tempVal = $curNode->getAttribute("childActivitySet");
                        if ($tempVal) {
                            $rule->mChildActivitySet = $tempVal;
                        }
                        // Look for 'minimumCount'
                        $tempVal = $curNode->getAttribute("minimumCount");
                        if ($tempVal) {
                            $rule->mMinCount = $tempVal;
                        }
                
                        // Look for 'minimumPercent'
                        $tempVal = $curNode->getAttribute("minimumPercent");
                        if ($tempVal) {
                            $rule->mMinPercent = $tempVal;
                        }
                        $rule->mConditions['_SeqConditionSet'] = new SeqConditionSet(true);
                        $conditions = array();
                        $ruleInfo = $curNode->childNodes;
                        for ($j = 0; $j < $ruleInfo->length; $j++) {
                            $curRule = $ruleInfo->item($j);
                            //check for element
                            if ($curRule->nodeType == XML_ELEMENT_NODE) {
                                if ($curRule->localName == "rollupConditions") {
                                    $tempVal = $curRule->getAttribute("conditionCombination");
                                    if ($tempVal) {
                                        $rule->mConditions['_SeqConditionSet']->mCombination = $tempVal;
                                    } else {
                                        $rule->mConditions['_SeqConditionSet']->mCombination = COMBINATION_ANY;
                                    }
                                    $conds = $curRule->childNodes;
                                    for ($k = 0; $k < $conds->length; $k++) {
                                        $con = $conds->item($k);
                                        if ($con->nodeType == XML_ELEMENT_NODE) {
                                            if ($con->localName == "rollupCondition") {
                                                $cond = new SeqCondition();
                                                // Look for 'condition'
                                                $tempVal = $con->getAttribute("condition");
                                                if ($tempVal) {
                                                    $cond->mCondition = $tempVal;
                                                }
                                                // Look for 'operator'
                                                $tempVal = $con->getAttribute("operator");
                                                if ($tempVal) {
                                                    if ($tempVal == 'not') {
                                                        $cond->mNot = true;
                                                    } else {
                                                        $cond->mNot = false;
                                                    }
                                                }
                                                //add class
                                                $c_cond['_SeqCondition'] = $cond;
                                                array_push($conditions, $c_cond);
                                            }
                                        }
                                    }
                                } elseif ($curRule->localName == "rollupAction") {
                                    $tempVal = $curRule->getAttribute("action");
                                    if ($tempVal) {
                                        $rule->setRollupAction($tempVal);
                                    }
                                }
                            }
                        }
                        // Add the conditions to the condition set for the rule
                        $rule->mConditions['_SeqConditionSet']->mConditions = $conditions;
 
                        // Add the rule to the ruleset
                        //add class
                        $c_rule['_SeqRollupRule'] = $rule;
                        array_push($rollupRules, $c_rule);
                    }
                }
            }
         
            if ($rollupRules != null) {
                $rules = new SeqRollupRuleset($rollupRules);
                // Set the Activity's rollup rules
                //add class
                $c_rules['_SeqRollupRuleset'] = $rules;
                $ioAct->setRollupRules($c_rules);
            }
 
            return $ioAct;
        }
   
   
        public static function getSequencingRules($iNode, $ioAct)
        {
            //local variables
            $ok = true;
            $tempVal = null;
 
            $preRules = array();
            $exitRules = array();
            $postRules = array();
 
            //get children
            $children = $iNode->childNodes;
        
            //find sequencing rules
            for ($i = 0; $i < $children->length; $i++) {
                $curNode = $children->item($i);
                if ($curNode->nodeType == XML_ELEMENT_NODE) {
                    if ($curNode->localName == "preConditionRule" || $curNode->localName == "exitConditionRule" || $curNode->localName == "postConditionRule") {
                        $rule = new SeqRule();
                        $ruleInfo = $curNode->childNodes;
                        for ($j = 0; $j < $ruleInfo->length; $j++) {
                            $curRule = $ruleInfo->item($j);
                            //echo "$curRule->localName\n";
                            if ($curRule->nodeType == XML_ELEMENT_NODE) {
                                if ($curRule->localName == "ruleConditions") {
                                    $rule->mConditions = self::extractSeqRuleConditions($curRule);
                                } elseif ($curRule->localName == "ruleAction") {
                                    $tempVal = $curRule->getAttribute("action");
                                    if ($tempVal) {
                                        $rule->mAction = $tempVal;
                                    }
                                }
                            }
                        }//end for inner
                        if ($rule->mConditions != null && $rule->mAction != null) {
                            //changed from ADL Code..
                            if ($curNode->localName == "preConditionRule") {
                                //echo "ADD PRE";
                                //add class
                                $c_rule['_SeqRule'] = $rule;
                                array_push($preRules, $c_rule);
                            }
                            if ($curNode->localName == "exitConditionRule") {
                                //echo "ADD EXIT";
                                //add class
                                $c_rule['_SeqRule'] = $rule;
                                array_push($exitRules, $c_rule);
                            }
                            if ($curNode->localName == "postConditionRule") {
                                //echo "ADD POST";
                                //add class
                                $c_rule['_SeqRule'] = $rule;
                                array_push($postRules, $c_rule);
                            }
                        }
                    } //end if preCondition
                }  //end if ELEMENT
            }
        
            if (count($preRules) > 0) {
                $rules = new SeqRuleset($preRules);
                //add class
                $c_rules['_SeqRuleset'] = $rules;
                $ioAct->setPreSeqRules($c_rules);
            }
    
            if (count($exitRules) > 0) {
                $rules = new SeqRuleset($exitRules);
                //add class
                $c_rules['_SeqRuleset'] = $rules;
                $ioAct->setExitSeqRules($c_rules);
            }
            if (count($postRules) > 0) {
                $rules = new SeqRuleset($postRules);
                //add class
                $c_rules['_SeqRuleset'] = $rules;
                $ioAct->setPostSeqRules($c_rules);
            }
            //echo json_encode($ioAct);
        
            return $ioAct;
        }
    
        public static function extractSeqRuleConditions($iNode)
        {
            $tempVal = null;
            $condSet = new SeqConditionSet(false);
 
            $conditions = array();
            $tempVal = $iNode->getAttribute("conditionCombination");
            if ($tempVal) {
                $condSet->mCombination = $tempVal;
            } else {
                $condSet->mCombination = COMBINATION_ALL;
            }
            $condInfo = $iNode->childNodes;
            for ($i = 0; $i < $condInfo->length; $i++) {
                $curCond = $condInfo->item($i);
                if ($curCond->nodeType == XML_ELEMENT_NODE) {
                    if ($curCond->localName == "ruleCondition") {
                        $cond = new SeqCondition();
                    
                        //look for condition
                        $tempVal = $curCond->getAttribute("condition");
                        if ($tempVal) {
                            $cond->mCondition = $tempVal;
                        }
 
                        // Look for 'referencedObjective'
                        $tempVal = preg_replace('/(%20)+/', ' ', trim($curCond->getAttribute("referencedObjective")));
                        if ($tempVal) {
                            $cond->mObjID = $tempVal;
                        }
    
                        // Look for 'measureThreshold'
                        $tempVal = $curCond->getAttribute("measureThreshold");
                        if ($tempVal) {
                            $cond->mThreshold = $tempVal;
                        }
        
                        // Look for 'operator'
                        $tempVal = $curCond->getAttribute("operator");
                        if ($tempVal) {
                            if ($tempVal == 'not') {
                                $cond->mNot = true;
                            } else {
                                $cond->mNot = false;
                            }
                        }
                    
                        //add class
                        $c_cond['_SeqCondition'] = $cond;
                        array_push($conditions, $c_cond);
                    }
                }
            }
        
            if (count($conditions) > 0) {
                $condSet->mConditions = $conditions;
            } else {
                $condSet->mConditions = null;
            }
            //add class
            $c_condSet['_SeqConditionSet'] = $condSet;
            return $c_condSet;
        }
   
        public static function getAuxResources($iNode, $ioAct)
        {
            $ok = true;
            $tempVal = null;
            $auxRes = array();
            //get children
            $children = $iNode->childNodes;
 
            //find  ressources
            for ($i = 0; $i < $children->length; $i++) {
                $curNode = $children->item($i);
                if ($curNode->nodeType == XML_ELEMENT_NODE) {
                    if ($curNode->localName == "auxiliaryResource") {
                        //found it
                        $res = new ADLAuxiliaryResource();
                    
                        // Get the resource's purpose
                        $tempVal = $curNode->getAttribute("purpose");
                        if ($tempVal) {
                            $res->mType = $tempVal;
                        }
                        // Get the resource's ID
                        $tempVal = preg_replace('/(%20)+/', ' ', trim($curNode->getAttribute("auxiliaryResourceID")));
                        if ($tempVal) {
                            $res->mResourceID = $tempVal;
                        }
                        array_push($auxRes, $res);
                    }
                }
            }
            //add class
            $c_auxRes['_ADLAuxiliaryResource'] = $auxRes;
            $ioAct->setAuxResources($c_auxRes);
            return $ioAct;
        }
    
        //helper functions
    
        private static function convert_to_bool($string)
        {
            if (strtoupper($string) == "FALSE") {
                return false;
            } else {
                return true;
            }
        }
    
    
        private static function lookupElement($iNode, $iElement)
        {
            $value = null;
            $curNode = null;
            $children = null;
        
            if ($iNode != null && $iElement != null) {
                $children = $iNode->childNodes;
                for ($i = 0; $i < $children->length; $i++) {
                    $curNode = $children->item($i);
                    if (($curNode->nodeType == XML_ELEMENT_NODE)) {
                        if ($curNode->localName == $iElement) {
                            break;
                        }
                    }
                }
                if ($curNode != null) {
                    $comp = $curNode->localName;
                    if ($comp != null) {
                        if ($comp != $iElement) {
                            $curNode = null;
                        }
                    } else {
                        $curNode = null;
                    }
                }
            } else {
                //$iElement is null
                $curNode = $iNode;
            }
      
            if ($curNode != null) {
                $children = $curNode->childNodes;
                if ($children != null) {
                    for ($i = 0; $i < $children->length; $i++) {
                        $curNode = $children->item($i);
                        // make sure we have a 'text' element
                        if (($curNode->nodeType == XML_TEXT_NODE) || ($curNode->nodeType == XML_CDATA_SECTION_NODE)) {
                            $value = $value . $curNode->nodeValue;
                        }
                    }
                }
            }
            return $value;
        }
    }     //end class