pronto/core/record_model.php

Go to the documentation of this file.

<?php
class RecordModel_Base
{
        var $db      = null;
        var $web     = null;
        var $cache   = null;
        var $depends = null;
        var $plugins = null;

        var $context = null;

        /*
         * Variables below are to be overridden by subclasses
         */

        var $table = null;
        var $pk = 'id';
        var $enable_cache = false;

        var $submodels = null;

        var $files = null;

        function RecordModel_Base()
        {
                $this->db        =& Registry::get('pronto:db:main');
                $this->cache     =& Registry::get('pronto:cache');
                $this->web       =& Registry::get('pronto:web');
                $this->validator =& Registry::get('pronto:validator');

                // this isn't a very smart inflector -- best to explicitly set the
                // table name in the model itself
                if(is_null($this->table) || empty($this->table)) {
                        $this->table = strtolower(substr(get_class($this),1)).'s';
                }

                // load plugins
                $this->plugins =& Registry::get('pronto:plugins');

                if(method_exists($this, '__init__')) {
                        $this->__init__();
                }
        }

        function depend($model)
        {
                foreach(func_get_args() as $name) {
                        if(isset($this->depends->$name)) continue;
                        $this->depends->$name =& Factory::model($name);
                }
        }

        function &import_plugin($name)
        {
                foreach(func_get_args() as $name) {
                        $class =& Factory::plugin($name, 'page');
                        if($class === false) {
                                trigger_error("Plugin $name does not exist");
                                die;
                        }
                }
                // reload $this->plugins
                $this->plugins =& Registry::get('pronto:plugins');
                if($class) return $class;
        }

        function purify($data)
        {
                require_once(DIR_FS_PRONTO.DS.'extlib'.DS.'safehtml'.DS.'safehtml.php');
                foreach($data as $k=>$v) {
                        if(is_array($v)) {
                                // PHP4 doesn't like self::purify()
                                $data[$k] = RecordModel::purify($v);
                        } else if(class_exists('safehtml')) {
                                $purifier = new safehtml();
                                $data[$k] = $purifier->parse($v);
                        }
                }
                return $data;
        }

        function invalidate($id)
        {
                if(!is_array($id)) $id = array($id);
                foreach($id as $i) {
                        if($this->enable_cache && $this->cache) {
                                $key = 'model_'.get_class($this)."_{$this->pk}_$i";
                                $this->cache->delete($key);
                        }
                }
        }

        function find()
        {
                $args = func_get_args();
                $q    = array_shift($args);
                return new RecordSelector($q, $args, $this);
        }

        function find_arr($q, $args=array())
        {
                return new RecordSelector($q, $args, $this);
        }

        /*********************************************************************
         * PRIMITIVES
         *
         * These methods are very basic and have no knowledge of the cache or
         * any higher-order data handling.  Do not override these unless you
         * really know what you're doing.
         *********************************************************************/

        function fetch($id)
        {
                $q = $this->db->query("SELECT * FROM {$this->table} WHERE \"{$this->pk}\"='%s' LIMIT 1", array($id));
                return $this->db->get_item($q);
        }

        function store($data)
        {
                $data = $this->sanitize($data);
                if(isset($data[$this->pk])) {
                        $this->db->update_row($this->table, $data, $this->pk."='%s'", array($data[$this->pk]));
                        return $data[$this->pk];
                } else {
                        return $this->db->insert_row($this->table, $data);
                }
        }

        function erase($id)
        {
                $q = $this->db->query("DELETE FROM {$this->table} WHERE \"{$this->pk}\"='%s' LIMIT 1", array($id));
                return $this->db->execute($q);
        }

        /*********************************************************************
         * HIGHER-ORDER, CACHE-AWARE
         *
         * These are the methods that will be called by other components of
         * the application.  These methods will then call the "cache-transparent"
         * methods defined below  The "cache-transparent" methods are the ones
         * you should override.
         *
         * Don't override these, unless you know what you're doing.
         *********************************************************************/

        function create()
        {
                return $this->create_record();
        }

        function load($id)
        {
                if($this->enable_cache && $this->cache) {
                        $key = 'model_'.get_class($this)."_{$this->pk}_$id";
                        $rec =& $this->cache->get($key);
                        if(!$rec) {
                                $rec = $this->load_record($id);
                                $this->cache->set($key, $rec);
                        }
                        return $rec;
                }
                return $this->load_record($id);
        }

        function load_all($ids, $ignore_empty=true)
        {
                $data = array();
                foreach($ids as $id) {
                        $rec = $this->load($id);
                        if($rec || !$ignore_empty) $data[] = $rec;
                }
                return $data;
        }

        function save($data)
        {
                if($data[$this->pk]) $this->invalidate($data[$this->pk]);
                return $this->save_record($data);
        }

        function delete($id)
        {
                $this->invalidate($id);
                return $this->delete_record($id);
        }

        /*********************************************************************
         * HIGHER-ORDER, CACHE-TRANSPARENT
         *   (OVERRIDE THESE)
         *********************************************************************/

        function create_record()
        {
                return array();
        }

        function load_record($id)
        {
                $data = $this->fetch($id);
                if(!$data) return false;

                // Load in entities from other models on which this one depends.
                //
                // Note: At present, this facility can only link to other entities
                // by primary key.
                if(is_array($this->submodels)) foreach($this->submodels as $dep) {
                        if(is_array($dep)) {
                                // use the model=>column_name pattern
                                $mod = $dep[0];
                                $col = $dep[1];
                        } else {
                                // use the implicit column name of "<model>_id"
                                $col = "{$dep}_id";
                                $mod = $dep;
                        }
                        $this->depend($mod);
                        $data[$dep] = $this->depends->$mod->load($data[$col]);
                }

                // Load in web locations for files.  The model subclass can override these
                // if necessary.
                if(is_array($this->files)) foreach($this->files as $k=>$f) {
                        $fn = $f['filename'];
                        foreach($data as $dk=>$dv) {
                                if(is_array($dv)) continue;
                                $fn = str_replace("<$dk>", $dv, $fn);
                        }
                        if(!file_exists($f['fileroot'].DS.$fn)) continue;
                        $data[$k] = $f['webroot'].'/'.$fn;
                };

                return $data;
        }

        function save_record($data)
        {
                return $this->store($data);
        }

        function delete_record($id)
        {
                return $this->erase($id);
        }

        function validate($data)
        {
                return array();
        }

        function sanitize($data)
        {
                $data = $this->purify($data);
                return $data;
        }


        function enum_schema()
        {
                return array(
                        'from'       => $this->table,
                        'exprs'      => array(),
                        'gexprs'     => array(),
                        'select'     => '*',
                        'where'      => '',
                        'group_by'   => '',
                        'having'     => '',
                        'order'      => "{$this->pk} ASC",
                        'limit'      => 50
                );
        }
}

?>

---