snap2/content/SnapContent.php5

<?php

abstract class SnapContent extends SObject {
    private $raw = "";
    private $inSync = true;
    private $content = array();
    private $readOnly = false;
    private $notrans = false;

    protected $version = null;

    private $editorClass = '';
    private $previewClass = '';
    private $translatorClass = '';
    private $suffix = '';
    private $name = '';

    public static $CONTENT_MODULES;

    private static $init = false;

    public function __construct($version, $raw = false) {
        parent::__construct();

        if(isset($this->NEED_TRANSLATION))
            $notrans = !$this->NEED_TRANSLATION;
        else
            $notrans = false;

        if($raw !== false) {
            if($notrans)
                $this->content = $raw;
            else
                $this->content = json_decode($raw, true);
            $this->raw = $raw;
            $this->readOnly = true;
        }

        $this->notrans = $notrans;
        $this->version = $version;

        if($version) {
            $type = $version->getResource()->getContentType();
            $this->editorClass = self::$CONTENT_MODULES[$type]['editor'];
            $this->previewClass = self::$CONTENT_MODULES[$type]['preview'];
            $this->translatorClass = self::$CONTENT_MODULES[$type]['translator'];
            $this->suffix = self::$CONTENT_MODULES[$type]['suffix'];
            $this->name = self::$CONTENT_MODULES[$type]['name'];
        }
    }

    /*
     * Public Interface Methods
     */

    public static function getContentModule($version, $new = false) {
        $type = $version->getResource()->getContentType();
        $cl = self::$CONTENT_MODULES[$type]['contentModule'];
        if($new)
            return new $cl($version);
        else
            return new $cl($version, $version->getContent());
    }

    public static function getContentModuleClass($version) {
        $type = $version->getResource()->getContentType();
        return self::$CONTENT_MODULES[$type]['contentModule'];
    }

    public static function isValidType($type) {
        return isset(self::$CONTENT_MODULES[$type]);
    }

    public static function create($version) {
        $type = $version->getResource()->getContentType();
        $cl = self::$CONTENT_MODULES[$type]['contentModule'];
        return new $cl($version);
    }

    public static function getInitialValue($type) {
        $cl = SnapContent::$CONTENT_MODULES[$type]['contentModule'];
        if(method_exists($cl, 'initialValue')) {
            $content = call_user_func(array($cl, 'initialValue'));
        }
        else
            $content = "";
        return $content;
    }

    public function getEditor($redirectTo = "", $showPreview = true) {
        $cl = $this->editorClass;
        return new $cl($this->version, $redirectTo, $showPreview);
    }

    public function getEditorClass() {
        return $this->editorClass;
    }

    public function getPreview($mode = TKSnapPreview::MODE_DEFAULT) {
        $cl = $this->previewClass;
        return new $cl($this->version, $mode);
    }

    public function getPreviewClass() {
        return $this->previewClass;
    }

    public function getTranslator() {
        return $this->translatorClass;
    }

    public function getName() {
        return $this->name;
    }

    public static function getContentName($type) {
        if(!isset(self::$CONTENT_MODULES[$type]))
            return "???";
        else
            return self::$CONTENT_MODULES[$type]['name'];
    }

    public static function getTypeFromSuffix($suffix) {
        foreach(self::$CONTENT_MODULES as $type => $cminfo) {
            if(in_array($suffix, $cminfo['suffixes']))
                return $type;
        }

        return false;
    }

    public function getRaw() {
        if(!$this->inSync) {
            if($this->notrans)
                $this->raw = $this->content;
            else
                $this->raw = json_encode($this->content);
        }
        $this->inSync = true;
        return $this->raw;
    }

    public function copy() {
        $cp = $this->doCopy();
        $cp->readOnly = true;
        return $cp;
    }

    public function delete() {
        return $this->doDelete();
    }

    public function getLinkURL($download = false) {
        if($download)
            $dn = 'download';
        else
            $dn = 'content';
        if($this->suffix === false)
            $this->suffix = $this->getSuffix();
        $id = $this->version->getId();
        $active = $this->version->getResource()->getActiveVersion();
        if(!$active || $active->getId() != $id)
            return Snap2::getMediaURLBase() . "/$dn" . $this->version->getCanonicalPath()
                . "." . $this->suffix;
        else
            return Snap2::getMediaURLBase() . "/$dn" . $this->version->getResource()->getCanonicalPath()
                . "." . $this->suffix;
    }

    public function getContentSuffix() {
        if($this->suffix === false)
            $this->suffix = $this->getSuffix();
        return $this->suffix;
    }

    public function getHTML($params = array()) {
        return $this->doGetHTML($params);
    }

    public function isValid() {
        return $this->validate();
    }

    /*
     * Utility Methods for Derived Classes
     */

    protected function set($field, $value) {
        if($this->readOnly) {
            $this->setError("Cannot set field '$field' on read-only content module");
            return false;
        }
        $this->content[$field] = $value;
        $this->inSync = false;
        return true;
    }

    protected function setAll($values) {
        if($this->readOnly) {
            $this->setError("Cannot set fields on read-only content module");
            return false;
        }
        $this->content = $values;
        $this->inSync = false;
        return true;
    }

    protected function get($field) {
        if(!isset($this->content[$field])) {
            return null;
        }
        return $this->content[$field];
    }

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

    /*
     * Methods to be Overridden by Derived Classes
     */

    protected function doCopy() {
        $cl = get_class($this);
        $cm = new $cl($this->version, $this->getRaw());
        $cm->readOnly = true;
        return $cm;
    }

    protected function doDelete() {
        return true;
    }

    protected function getSuffix() {
        return "bin";
    }

    protected abstract function doGetHTML($params);

    protected abstract function validate();

    public abstract function checkMedia();
    public abstract function updateFileList();
}

?>

---