webadmin.php

/var/www/(Del)gepgroup.hk/common/ActiveRecordModel.php

<?php
require_once( realpath(dirname(__FILE__)) . '/connection.php');
class ActiveRecordModelBase extends ActiveRecord\Model
{
    static $fckeditor_attributes = array();
    
    public function delete()
    {
        // Initial this->errors, for add errors
        require_once( realpath(dirname(__FILE__)) . '/../php-activerecord/lib/Validations.php');

        $validator = new ActiveRecord\Validations($this);
        $this->errors = $validator->get_record();
        
        return parent::delete();
    }
    
    public function safe_set_attributes($attributes, $values=array(), $attribute_formatters=array())
    {
        $table = static::table();
        $formatters = array();
        
        $formatters[] = new IgnoreAttributeFormatter(array('id'));
        $formatters[] = new FCKEditorAttributeFormatter(static::$fckeditor_attributes);
        foreach ($attribute_formatters as $formatter)
            $formatters[] = $formatter;
        $formatters[] = new DefaultAttributeFormatter();
        
        foreach ($attributes as $attribute => $value)
        {
            if (array_key_exists($attribute, $table->columns))
            {
                foreach ($formatters as $formatter)
                {
                    if ($formatter->is_support($attribute))
                    {
                        if ($formatter->is_update($attribute))
                            $values[$attribute] = $formatter->format($attribute, $value);
                        break;
                    }
                }
            }
        }
        $this->set_attributes($values);
    }
    
    // This method source code is copy from update_all()
    // options support joins
    public static function mysql_update_all($options=array())
    {
        $table = static::table();
        $conn = static::connection();
        
        $table_with_joins = $table->get_fully_qualified_table_name();
        if (isset($options['joins']) && ($joins = $options['joins']))
            $table_with_joins .= ' ' . $joins;
        
        $sql = new ActiveRecord\SQLBuilder($conn, $table_with_joins);

        // Following code no changed
        $sql->update($options['set']);

        if (isset($options['conditions']) && ($conditions = $options['conditions']))
        {
            if (is_array($conditions) && !ActiveRecord\is_hash($conditions))
                call_user_func_array(array($sql, 'where'), $conditions);
            else
                $sql->where($conditions);
        }

        if (isset($options['limit']))
            $sql->limit($options['limit']);

        if (isset($options['order']))
            $sql->order($options['order']);

        $values = $sql->bind_values();
        $ret = $conn->query(($table->last_sql = $sql->to_s()), $values);
        return $ret->rowCount();
    }
}

//class MemberActiveRecordModel extends ActiveRecordModelBase
//{
//    static $before_create = array('fill_before_create');
//    static $before_update = array('fill_before_update');
//    
//    static $belongs_to = array(
//        array('create_user', 'class_name' => 'Member', 'foreign_key' => 'create_by', 'readonly' => true),
//        array('modify_user', 'class_name' => 'Member', 'foreign_key' => 'modify_by', 'readonly' => true),
//    );
//    
//    public function fill_before_create()
//    {
//        $now = date("Y-m-d H:i:s");
//        //$now = $this->updated_at->format('Y-m-d H:i:s');
//        $this->create_on = $now;
//        $this->create_by = $_SESSION['member']['id'];
//        $this->modify_on = $now;
//        $this->modify_by = $_SESSION['member']['id'];
//    }
//    
//    public function fill_before_update()
//    {
//        $now = date("Y-m-d H:i:s");
//        //$now = $this->updated_at->format('Y-m-d H:i:s');
//        $this->modify_on = $now;
//        $this->modify_by = $_SESSION['member']['id'];
//    }
//}

class ActiveRecordModel extends ActiveRecordModelBase
{
    static $before_create = array('fill_before_create');
    static $before_update = array('fill_before_update');
    
    static $belongs_to = array(
        array('create_user', 'class_name' => 'SysCmsUser', 'foreign_key' => 'create_by', 'readonly' => true),
        array('modify_user', 'class_name' => 'SysCmsUser', 'foreign_key' => 'modify_by', 'readonly' => true),
    );
    
    public function fill_before_create()
    {
        $now = date("Y-m-d H:i:s");
        //$now = $this->updated_at->format('Y-m-d H:i:s');
        $this->create_on = $now;
        $this->create_by = $_SESSION['webadmin']['id'];
        $this->modify_on = $now;
        $this->modify_by = $_SESSION['webadmin']['id'];
    }
    
    public function fill_before_update()
    {
        $now = date("Y-m-d H:i:s");
        //$now = $this->updated_at->format('Y-m-d H:i:s');
        $this->modify_on = $now;
        $this->modify_by = $_SESSION['webadmin']['id'];
    }
    
    public function assign_sort_if_empty($options=array())
    {
        if (!strlen($this->sort) || $this->sort == '0')
        {
            // Get max sort
            if (!isset($options['select']))
                $options['select'] = 'MAX(sort) AS max_sort';
            $all = static::all($options);
            $model = $all[0];
            $max_sort = strlen($model->max_sort) ? $model->max_sort : 0;
            
            // Assign sort
            $this->sort = $max_sort + 1;
        }
    }
}

abstract class AttributeFormatter
{
    abstract public function is_support($attribute);
    abstract public function is_update($attribute);
    abstract public function format($attribute, $value);
}

class CustomAttributeFormatter extends AttributeFormatter
{
    private $is_support_closure;
    private $is_update_closure;
    private $format_closure;
    
    function __construct($is_support_closure, $is_update_closure, $format_closure)
    {
        $this->is_support_closure = $is_support_closure;
        $this->is_update_closure = $is_update_closure;
        $this->format_closure = $format_closure;
    }
    
    public function is_support($attribute)
    {
        $closure = $this->is_support_closure;
        return $closure($attribute);
    }
    
    public function is_update($attribute)
    {
        $closure = $this->is_update_closure;
        return $closure($attribute);
    }
    
    public function format($attribute, $value)
    {
        $closure = $this->format_closure;
        return $closure($value);
    }
}

class IgnoreAttributeFormatter extends AttributeFormatter
{
    private $support_attributes;
    
    function __construct($support_attributes)
    {
        $this->support_attributes = empty($support_attributes) ? array() : $support_attributes;
    }
    
    public function is_support($attribute)
    {
        return in_array($attribute, $this->support_attributes);
    }
    
    public function is_update($attribute)
    {
        return false;
    }
    
    public function format($attribute, $value)
    {
        throw new Exception('Not support format.');
    }
}

class FCKEditorAttributeFormatter extends AttributeFormatter
{
    private $support_attributes;
    
    function __construct($support_attributes)
    {
        $this->support_attributes = empty($support_attributes) ? array() : $support_attributes;
    }
    
    public function is_support($attribute)
    {
        return in_array($attribute, $this->support_attributes);
    }
    
    public function is_update($attribute)
    {
        return true;
    }
    
    public function format($attribute, $value)
    {
        return preg_replace("/'/", "\'", $value);
    }
}

class DefaultAttributeFormatter extends AttributeFormatter
{
    public function is_support($attribute)
    {
        return true;
    }
    
    public function is_update($attribute)
    {
        return true;
    }
    
    public function format($attribute, $value)
    {
        return strlen($value) ? htmlspecialchars($value, ENT_QUOTES) : NULL;
    }
}