snap2/content/SnapContentLessonPlan.php5

<?php

class SnapContentLessonPlan extends SnapContent {
    protected $NEED_TRANSLATION = TRUE;
    protected $lessonTitle = "";
    protected $gradeLevel = "";
    protected $lessonAbstract = "";
    protected $standardsAddressed = "";
    protected $objectives = "";
    protected $prereqs = "";
    protected $errors = array();
    protected $currentXML = false;

    public static $PROTOTYPES = array(
        'introduction' => array(
            'name' => 'Introduction',
            'required' => true,
            'note' => false
        ),
        'exploration' => array(
            'name' => 'Exploration',
            'required' => true,
            'note' => false
        ),
        'phys_modeling' => array(
            'name' => 'Physical Modeling and Measurement',
            'required' => true,
            'note' => false
        ),
        'comp_modeling' => array(
            'name' => 'Computational Modeling',
            'required' => true,
            'note' => false
        ),
        'conclusion' => array(
            'name' => 'Conclusion',
            'required' => true,
            'note' => false
        ),
        'follow_up' => array(
            'name' => 'Follow Up',
            'required' => false,
            'note' => false
        ),
        'alternate' => array(
            'name' => 'Alternate Outline',
            'required' => false,
            'note' => false
        ),
        'guidedpractice' => array(
            'name' => 'Guided Practice',
            'required' => false,
            'note' => false
        ),
        'indeppractice' => array(
            'name' => 'Independent Practice',
            'required' => false,
            'note' => false
        )
    );

    public static $OUTLINES = array(
        'Custom' => array(),
        'Default Lesson Plan Template' => array('introduction', 'exploration', 'phys_modeling', 'comp_modeling',
                                                    'conclusion', 'follow_up', 'alternate')
    );

    public static $NICE_NAMES = array(
        'lessonTitle' => 'Title of Lesson',
        'gradeLevel' => 'Grade Level',
        'lessonAbstract' => 'Lesson Abstract',
        'standardsAddress' => 'Standards Addressed',
        'objectives' => 'Objectives',
        'prereqs' => 'Prequisite Knowledge',
        'teacherPrep' => 'Teacher Preparation',
        'requiredMaterials' => 'Required Materials',
        'mediaUsed' => 'Media Used',
        'requiredEquipment' => 'Required Equipment',
        'safety' => 'Safety Reminders',
        'keyterms' => 'Key Terms'
    );

    public function setStandardFields($contentArray) {
        $keys = array('lessonTitle', 'gradeLevel', 'lessonAbstract', 'standardsAddressed', 'objectives',
                        'prereqs', 'teacherPrep', 'requiredMaterials', 'mediaUsed', 'requiredEquipment',
                        'safety', 'keyterms');

        foreach ($keys as $key) {
            if(($errors = $this->isKeyValid($key, $contentArray)) !== true) {
                foreach($errors as $e)
                    $this->errors[] = $e;
            }
        }

        if(count($this->errors) > 0)
            return false;

        $old = $this->getAll();

        $this->set('lessonTitle', $contentArray['lessonTitle']);
        $this->set('gradeLevel', $contentArray['gradeLevel']);
        $this->set('lessonAbstract', $contentArray['lessonAbstract']);
        $this->set('standardsAddressed', $contentArray['standardsAddressed']);
        $this->set('objectives', $contentArray['objectives']);
        $this->set('prereqs', $contentArray['prereqs']);
        $this->set('teacherPrep', $contentArray['teacherPrep']);
        $this->set('requiredMaterials', $contentArray['requiredMaterials']);
        $this->set('mediaUsed', $contentArray['mediaUsed']);
        $this->set('requiredEquipment', $contentArray['requiredEquipment']);
        $this->set('safety', $contentArray['safety']);
        $this->set('keyterms', $contentArray['keyterms']);

        $errors = $this->generateXML();
        if($errors !== true) {
            $this->setAll($old);
            $this->errors += $errors;
            return false;
        }
        return true;
    }

    public function setOutlineType($type) {
        $oldOutline = $this->get('outlineType');
        if(!isset(self::$OUTLINES[$type])) {
            $this->errors[] = 'No such outline type "' . $type . '"';
            return false;
        }
        if($oldOutline && $oldOutline != $type) {
            // migrate existing fields, if any, to the new outline, and throw errors for ones that can't be migrated
            //  (or warnings?)
            $events = $this->get('events');
            $newEvents = array();
            foreach($events as $evt) {
                // throw away custom fields: can't reasonably do anything with those
                if(!is_string($evt['proto']))
                    continue;
                if(in_array($evt['proto'], self::$OUTLINES[$type]))
                    $newEvents[] = $evt;
            }
            $this->set('events', $newEvents);
        }
        $this->set('outlineType', $type);
        return true;
    }

    public function setOutlineField($sname, $time, $content) {
        $outlineType = $this->get('outlineType');
        if(!$outlineType) {
            $this->errors[] = 'INTERNAL: You must select an outline type first before setting fields';
            return false;
        }
        if(is_array($sname)) {
            if($outlineType != 'Custom') {
                $this->errors[] = 'INTERNAL: You cannot have custom prototypes unless the outline type is "Custom"';
                return false;
            }
            if(!isset($sname['name']) || !isset($sname['required']) || !isset($sname['note'])
                || !is_string($sname['name']) || !is_bool($sname['required']) || !is_bool($sname['note'])
                || $sname['name'] == '')
            {
                $this->errors[] = 'INTERNAL: Custom prototype is incomplete: ' . print_r($sname, true);
                return false;
            }
            $name = $sname['name'];
        }
        else {
            if(!isset(self::$PROTOTYPES[$sname])) {
                $this->errors[] = 'INTERNAL: No such prototype: "' . $sname . '"';
                return false;
            }
            if($outlineType != 'Custom' && !in_array($sname, self::$OUTLINES[$outlineType])) {
                $this->errors[] = 'INTERNAL: Prototype "' . $sname . '" is not available in the selected template "'
                                    . $outlineType . '"';
                return false;
            }
            $name = self::$PROTOTYPES[$sname]['name'];
        }
        $time = htmlspecialchars($time);
        $tmp = $this->prepareXML($content, $name);
        if(is_array($tmp)) {
            foreach($tmp as $err)
                $this->errors[] = 'In field <b>' . $name . '</b> of Outline: ' . $err;
            return false;
        }
        $ret = SXMLHelper::validateXML('<XMLResource><section><p>' . $tmp . '</p></section></XMLResource>', true);
        if($ret !== true) {
            foreach($ret as $err)
                $this->errors[] = 'In field <b>' . $name . '</b> of Outline: ' . $err;
            return false;
        }
        $events = $this->get('events');
        $events[] = array(
            'proto' => $sname,
            'time' => $time,
            'content' => $content
        );
        $this->set('events', $events);
        return true;
    }

    public function getErrors() {
        return $this->errors;
    }

    public function clearErrors() {
        $this->errors = array();
    }

    public function cctHelper($matches) {
        return '<p><pre><![CDATA[' . base64_encode(htmlspecialchars($matches[1])) . ']]></pre></p>';
    }

    public function litHelper($matches) {
        return '<span><![CDATA[' . base64_encode(htmlspecialchars($matches[1])) . ']]></span>';
    }

    private function prepareXML($str, $field) {
        // fix entities
        $str = strtr($str, array('&lt;' => '&amp;lt;', '&gt;' => '&amp;gt;', '&amp;' => '&amp;amp;'));

        // convert code tags
        $str = preg_replace_callback('/(?![\\\\])<code>(.*?)<\/code>/ms', array($this, 'cctHelper'), $str);

        // process special escape sequences
        $str = EscapeParser::parseString($str, 'In field <b>' . $field . '</b>: ');
        if(is_array($str))
            return $str;        // we got some errors from the parser, so stop here

        // a few fixups for paragraphs
        $str = preg_replace("/\n[\t ]*\n/", "</p><p>", $str);
        $str = preg_replace("/\r[\t ]*\r/", "</p><p>", $str);
        $str = preg_replace("/\r\n[\t ]*\r\n/", "</p><p>", $str);

        return $str;
    }

    public function fixPreBlocks($matches) {
        return '<pre>' . htmlspecialchars(base64_decode($matches[1])) . '</pre>';
    }

    public function fixLitBlocks($matches) {
        $str = htmlspecialchars(base64_decode($matches[1]));

        // a few fixups for paragraphs
        $str = preg_replace("/\n[\t ]*\n/", "</p><p>", $str);
        $str = preg_replace("/\r[\t ]*\r/", "</p><p>", $str);
        $str = preg_replace("/\r\n[\t ]*\r\n/", "</p><p>", $str);

        return $str;
    }

    protected function isKeyValid($key, &$array) {
        if(!isset($array[$key]))
            return array('Missing field <b>' . $key . '</b>!  This is an internal error; please report it.');

        $errors = array();

        switch($key) {
            case 'lessonTitle':
            case 'gradeLevel':
            case 'lessonAbstract':
            case 'prereqs':
            case 'teacherPrep':
            case 'safety':
                if(!is_string($array[$key]) or $array[$key] == '') {
                    $errors[] = 'In field <b>' . self::$NICE_NAMES[$key] . '</b>: field is empty, or not a string';
                    break;
                }
                $tmp = $this->prepareXML($array[$key], self::$NICE_NAMES[$key]);
                if(is_array($tmp)) {
                    $errors += $tmp;
                    continue;
                }
                $ret = SXMLHelper::validateXML('<XMLResource><section><p>' . $tmp . '</p></section></XMLResource>', true);
                if($ret !== true) {
                    foreach($ret as $r)
                        $errors[] = 'In field <b>' . self::$NICE_NAMES[$key] . '</b>: ' . $r;
                }
                // just return the return value of validateXML() which will be true if everything's okay, or a set
                //   of errors if not, which will now be stored in errors
                break;
            case 'requiredMaterials':
            case 'standardsAddressed':
            case 'objectives':
            case 'requiredEquipment':
            case 'keyterms':
                if (!is_array($array[$key])) {
                    $errors[] = 'In field <b>' . self::$NICE_NAMES[$key]
                                    . '</b>: field must be an array (internal error: please report it';
                    break;
                }
                foreach($array[$key] as $i => $re) {
            //      $re = htmlspecialchars(htmlspecialchars($re));
                    $ret = SXMLHelper::validateXML('<XMLResource><section><p>' . $re . '</p></section></XMLResource>', true);
                    if($ret !== true) {
                        foreach($ret as $err)
                            $errors[] = 'In field <b>' . self::$NICE_NAMES[$key] . '</b>: ' . $err;
                    }
                    else
                        $array[$key][$i] = $re;
                }
                break;
        }

        if(count($errors) > 0)
            return $errors;
        else
            return true;
    }

    public function getOutlineType() {
        return $this->get('outlineType');
    }

    public function getOutlineFieldNames() {
        return self::$OUTLINES[$this->get('outlineType')];
    }

    public function getOutlineFields() {
        return $this->get('events');
    }

    public function getWhichOutline() {
        return $this->get('whichOutline');
    }

    public function getXML() {
        if(!$this->currentXML) {
            if(!$this->generateXML(true))
                return false;
        }
        return $this->currentXML;
    }

    private function generateXML($save = false) {
        $lessonTitle = $this->prepareXML($this->get('lessonTitle'), self::$NICE_NAMES['lessonTitle']);
        $gradeLevel = $this->prepareXML($this->get('gradeLevel'), self::$NICE_NAMES['gradeLevel']);
        $lessonAbstract = $this->prepareXML($this->get('lessonAbstract'), self::$NICE_NAMES['lessonAbstract']);

        $standardsArray = (is_array($this->get('standardsAddressed'))) ? $this->get('standardsAddressed') : array();
        $objectivesArray = (is_array($this->get('objectives'))) ? $this->get('objectives') : array();
        $materialsArray = (is_array($this->get('requiredMaterials'))) ? $this->get('requiredMaterials') : array();
        $mediaArray = (is_array($this->get('mediaUsed'))) ? $this->get('mediaUsed') : array();
        $equipmentArray = (is_array($this->get('requiredEquipment'))) ? $this->get('requiredEquipment') : array();
        $eventsArray = (is_array($this->get('events'))) ? $this->get('events') : array();
        $keytermsArray = (is_array($this->get('keyterms'))) ? $this->get('keyterms') : array();
        if(count($standardsArray) > 0)
            $standards = '<ul><li>' . implode('</li><li>', $standardsArray) . '</li></ul>';
        else
            $standards = '<i>none</i>';
        if(count($objectivesArray) > 0)
            $objectives = '<ul><li>' . implode('</li><li>', $objectivesArray) . '</li></ul>';
        else
            $objectives = '<i>none</i>';
        if(count($materialsArray) > 0)
            $materials = '<ul><li>' . implode('</li><li>', $materialsArray) . '</li></ul>';
        else
            $materials = '<i>none</i>';
        if(count($mediaArray) > 0)
            $media = '<ul><li>' . implode('</li><li>', $mediaArray) . '</li></ul>';
        else
            $media = '<i>none</i>';
        if(count($equipmentArray) > 0)
            $equipment = '<ul><li>' . implode('</li><li>', $equipmentArray) . '</li></ul>';
        else
            $equipment = '<i>none</i>';
        if(count($keytermsArray) > 0)
            $keyterms = '<ul><li>' . implode('</li><li>', $keytermsArray) . '</li></ul>';
        else
            $keyterms = '<i>none</i>';
        $prereqs = $this->prepareXML($this->get('prereqs'), self::$NICE_NAMES['prereqs']);
        $events = '';

        $errors = array();
        foreach($eventsArray as $thisEvent) {
            $events .= '<section mapping="event">';
            if(!isset($thisEvent['proto']) && isset($thisEvent['name'])) {
                $proto = array('name' => $thisEvent['name']);
                $this->setWarning('Please upgrade this lesson plan (edit and save)!');
            }
            else
                $proto = $thisEvent['proto'];
            if(is_string($proto))
                $proto = self::$PROTOTYPES[$proto];
            $events .= '<section mapping="eventName"><p>' . $proto['name'] . '</p></section>';
            $events .= '<section mapping="eventTime"><p>' . $thisEvent['time'] . "</p></section>";
            $xml = $this->prepareXML($thisEvent['content'], $proto['name']);
            if(is_array($xml))
                $errors += $xml;
            else
                $events .= '<section mapping="eventContent"><p>' . $xml . "</p></section>";
            $events .= "</section>";
        }

        $teacherPrep = $this->prepareXML($this->get('teacherPrep'), self::$NICE_NAMES['teacherPrep']);
        $safety = $this->prepareXML($this->get('safety'), self::$NICE_NAMES['safety']);

        if(is_array($lessonTitle)) $errors += $lessonTitle;
        if(is_array($gradeLevel)) $errors += $gradeLevel;
        if(is_array($lessonAbstract)) $errors += $lessonAbstract;
        if(is_array($prereqs)) $errors += $prereqs;
        if(is_array($teacherPrep)) $errors += $teacherPrep;
        if(is_array($safety)) $errors += $safety;

        if(count($errors) > 0)
            return $errors;

        $xmlString = <<<END_XML
<XMLResource>
    <section mapping="moduleInfo">
        <section mapping="moduleName"><p>$lessonTitle</p></section>
        <section mapping="moduleLevel"><p>$gradeLevel</p></section>
    </section>
    <section mapping="concepts">
        <section mapping="abstract">
            <p>$lessonAbstract</p>
        </section>
        <section mapping="standards">
            <p>$standards</p>
        </section>
        <section mapping="objectives">
            <p>$objectives</p>
        </section>
        <section mapping="keyterms">
            <p>$keyterms</p>
        </section>
    </section>
    <section mapping="prereq">
        <p>$prereqs</p>
    </section>
    <section mapping="teacherPrep">
        <p>$teacherPrep</p>
    </section>
    <section mapping="required">
        <section mapping="materials">
            <p>$materials</p>
        </section>
        <section mapping="media">
            <p>$media</p>
        </section>
        <section mapping="equipment">
            <p>$equipment</p>
        </section>
    </section>
    <section mapping="safety">
        <p>$safety</p>
    </section>
    <section mapping="outline">
        $events
    </section>
</XMLResource>
END_XML;

        $xmlString = preg_replace_callback('/<p><pre><!\[CDATA\[([a-zA-Z0-9+_\/=-]*)\]\]><\/pre><\/p>/',
                                            array($this, 'fixPreBlocks'), $xmlString);
        $xmlString = preg_replace_callback('/<span><!\[CDATA\[([a-zA-Z0-9+_\/=-]*)\]\]><\/span>/',
                                            array($this, 'fixLitBlocks'), $xmlString);

        $errors = SXMLHelper::validateXML($xmlString, true);

        if($errors !== true) {
            $this->currentXML = false;
            $errors[] = '<b>The above errors indicate that Snap2 had an internal error.  Please report those errors.</b>';
            return $errors;
        }

        if($save)
            $this->currentXML = $xmlString;
        return true;
    }

    public function getLessonTitle() {
        return $this->get('lessonTitle');
    }

    public function getGradeLevel() {
        return $this->get('gradeLevel');
    }

    public function getLessonAbstract() {
        return $this->get('lessonAbstract');
    }

    public function getStandardsAddressed() {
        return $this->get('standardsAddressed');
    }

    public function getObjectives() {
        return $this->get('objectives');
    }

    public function getPrereqs() {
        return $this->get('prereqs');
    }
    public function getTeacherPrep() {
        return $this->get('teacherPrep');
    }

    public function getRequiredMaterials() {
        return $this->get('requiredMaterials');
    }

    public function getMediaUsed() {
        return $this->get('mediaUsed');
    }

    public function getRequiredEquipment() {
        return $this->get('requiredEquipment');
    }

    public function getSafety() {
        return $this->get('safety');
    }

    public function getKeyTerms() {
        return $this->get('keyterms');
    }

    public function getEvent($whichEvent) {
        $event = $this->getEvents();
        return $event[$whichEvent];
    }

    public function getEvents() {
        return $this->get('events');
    }

    public function getEventName($whichEvent) {
        $event = $this->getEvent($whichEvent);
        return $event['name'];
    }

    public function getEventTime($whichEvent) {
        $event = $this->getEvent($whichEvent);
        return $event['time'];
    }

    public function getEventContent($whichEvent) {
        $event = $this->getEvent($whichEvent);
        return $event['content'];
    }

    protected function validate() {
        return true;
    }

    protected function doGetHTML($params) {
        return $this->getAll();
    }

    public function checkMedia() {
        return true;
    }

    public function updateFileList() {
        return true;
    }
}

?>

---