<?php
// +----------------------------------------------------------------------
// | ThinkPHP [ WE CAN DO IT JUST THINK IT ]
// +----------------------------------------------------------------------
// | Copyright (c) 2006-2014 http://thinkphp.cn All rights reserved.
// +----------------------------------------------------------------------
// | Licensed ( http://www.apache.org/licenses/LICENSE-2.0 )
// +----------------------------------------------------------------------
// | Author: liu21st <liu21st@gmail.com>
// +----------------------------------------------------------------------
namespace Think\Model;
use Think\Model;
/**
* ThinkPHP 聚合模型扩展
*/
class MergeModel extends Model {
protected $modelList = array(); // 包含的模型列表 第一个必须是主表模型
protected $masterModel = ''; // 主模型
protected $joinType = 'INNER'; // 聚合模型的查询JOIN类型
protected $fk = ''; // 外键名 默认为主表名_id
protected $mapFields = array(); // 需要处理的模型映射字段，避免混淆 array( id => 'user.id' )
/**
* 架构函数
* 取得DB类的实例对象 字段检查
* @access public
* @param string $name 模型名称
* @param string $tablePrefix 表前缀
* @param mixed $connection 数据库连接信息
*/
public function __construct($name='',$tablePrefix='',$connection=''){
parent::__construct($name,$tablePrefix,$connection);
// 聚合模型的字段信息
if(empty($this->fields) && !empty($this->modelList)){
$fields = array();
foreach($this->modelList as $model){
// 获取模型的字段信息
$result = $this->db->getFields(M($model)->getTableName());
$_fields = array_keys($result);
// $this->mapFields = array_intersect($fields,$_fields);
$fields = array_merge($fields,$_fields);
}
$this->fields = $fields;
}
// 设置第一个模型为主表模型
if(empty($this->masterModel) && !empty($this->modelList)){
$this->masterModel = $this->modelList[0];
}
// 主表的主键名
$this->pk = M($this->masterModel)->getPk();
// 设置默认外键名 仅支持单一外键
if(empty($this->fk)){
$this->fk = strtolower($this->masterModel).'_id';
}
}
/**
* 得到完整的数据表名
* @access public
* @return string
*/
public function getTableName() {
if(empty($this->trueTableName)) {
$tableName = array();
$models = $this->modelList;
foreach($models as $model){
$tableName[] = M($model)->getTableName().' '.$model;
}
$this->trueTableName = implode(',',$tableName);
}
return $this->trueTableName;
}
/**
* 自动检测数据表信息
* @access protected
* @return void
*/
protected function _checkTableInfo() {}
/**
* 新增聚合数据
* @access public
* @param mixed $data 数据
* @param array $options 表达式
* @param boolean $replace 是否replace
* @return mixed
*/
public function add($data='',$options=array(),$replace=false){
if(empty($data)) {
// 没有传递数据，获取当前数据对象的值
if(!empty($this->data)) {
$data = $this->data;
// 重置数据
$this->data = array();
}else{
$this->error = L('_DATA_TYPE_INVALID_');
return false;
}
}
// 启动事务
$this->startTrans();
// 写入主表数据
$result = M($this->masterModel)->strict(false)->add($data);
if($result){
// 写入外键数据
$data[$this->fk] = $result;
$models = $this->modelList;
array_shift($models);
// 写入附表数据
foreach($models as $model){
$res = M($model)->strict(false)->add($data);
if(!$res){
$this->rollback();
return false;
}
}
// 提交事务
$this->commit();
}else{
$this->rollback();
return false;
}
return $result;
}
/**
* 对保存到数据库的数据进行处理
* @access protected
* @param mixed $data 要操作的数据
* @return boolean
*/
protected function _facade($data) {
// 检查数据字段合法性
if(!empty($this->fields)) {
if(!empty($this->options['field'])) {
$fields = $this->options['field'];
unset($this->options['field']);
if(is_string($fields)) {
$fields = explode(',',$fields);
}
}else{
$fields = $this->fields;
}
foreach ($data as $key=>$val){
if(!in_array($key,$fields,true)){
unset($data[$key]);
}elseif(array_key_exists($key,$this->mapFields)){
// 需要处理映射字段
$data[$this->mapFields[$key]] = $val;
unset($data[$key]);
}
}
}
// 安全过滤
if(!empty($this->options['filter'])) {
$data = array_map($this->options['filter'],$data);
unset($this->options['filter']);
}
$this->_before_write($data);
return $data;
}
/**
* 保存聚合模型数据
* @access public
* @param mixed $data 数据
* @param array $options 表达式
* @return boolean
*/
public function save($data='',$options=array()){
// 根据主表的主键更新
if(empty($data)) {
// 没有传递数据，获取当前数据对象的值
if(!empty($this->data)) {
$data = $this->data;
// 重置数据
$this->data = array();
}else{
$this->error = L('_DATA_TYPE_INVALID_');
return false;
}
}
if(empty($data)){
// 没有数据则不执行
$this->error = L('_DATA_TYPE_INVALID_');
return false;
}
// 如果存在主键数据 则自动作为更新条件
$pk = $this->pk;
if(isset($data[$pk])) {
$where[$pk] = $data[$pk];
$options['where'] = $where;
unset($data[$pk]);
}
$options['join'] = '';
$options = $this->_parseOptions($options);
// 更新操作不使用JOIN
$options['table'] = $this->getTableName();
if(is_array($options['where']) && isset($options['where'][$pk])){
$pkValue = $options['where'][$pk];
}
if(false === $this->_before_update($data,$options)) {
return false;
}
$result = $this->db->update($data,$options);
if(false !== $result) {
if(isset($pkValue)) $data[$pk] = $pkValue;
$this->_after_update($data,$options);
}
return $result;
}
/**
* 删除聚合模型数据
* @access public
* @param mixed $options 表达式
* @return mixed
*/
public function delete($options=array()){
$pk = $this->pk;
if(empty($options) && empty($this->options['where'])) {
// 如果删除条件为空 则删除当前数据对象所对应的记录
if(!empty($this->data) && isset($this->data[$pk]))
return $this->delete($this->data[$pk]);
else
return false;
}
if(is_numeric($options) || is_string($options)) {
// 根据主键删除记录
if(strpos($options,',')) {
$where[$pk] = array('IN', $options);
}else{
$where[$pk] = $options;
}
$options = array();
$options['where'] = $where;
}
// 分析表达式
$options['join'] = '';
$options = $this->_parseOptions($options);
if(empty($options['where'])){
// 如果条件为空 不进行删除操作 除非设置 1=1
return false;
}
if(is_array($options['where']) && isset($options['where'][$pk])){
$pkValue = $options['where'][$pk];
}
$options['table'] = implode(',',$this->modelList);
$options['using'] = $this->getTableName();
if(false === $this->_before_delete($options)) {
return false;
}
$result = $this->db->delete($options);
if(false !== $result) {
$data = array();
if(isset($pkValue)) $data[$pk] = $pkValue;
$this->_after_delete($data,$options);
}
// 返回删除记录个数
return $result;
}
/**
* 表达式过滤方法
* @access protected
* @param string $options 表达式
* @return void
*/
protected function _options_filter(&$options) {
if(!isset($options['join'])){
$models = $this->modelList;
array_shift($models);
foreach($models as $model){
$options['join'][] = $this->joinType.' JOIN '.M($model)->getTableName().' '.$model.' ON '.$this->masterModel.'.'.$this->pk.' = '.$model.'.'.$this->fk;
}
}
$options['table'] = M($this->masterModel)->getTableName().' '.$this->masterModel;
$options['field'] = $this->checkFields(isset($options['field'])?$options['field']:'');
if(isset($options['group']))
$options['group'] = $this->checkGroup($options['group']);
if(isset($options['where']))
$options['where'] = $this->checkCondition($options['where']);
if(isset($options['order']))
$options['order'] = $this->checkOrder($options['order']);
}
/**
* 检查条件中的聚合字段
* @access protected
* @param mixed $data 条件表达式
* @return array
*/
protected function checkCondition($where) {
if(is_array($where)) {
$view = array();
foreach($where as $name=>$value){
if(array_key_exists($name,$this->mapFields)){
// 需要处理映射字段
$view[$this->mapFields[$name]] = $value;
unset($where[$name]);
}
}
$where = array_merge($where,$view);
}
return $where;
}
/**
* 检查Order表达式中的聚合字段
* @access protected
* @param string $order 字段
* @return string
*/
protected function checkOrder($order='') {
if(is_string($order) && !empty($order)) {
$orders = explode(',',$order);
$_order = array();
foreach ($orders as $order){
$array = explode(' ',trim($order));
$field = $array[0];
$sort = isset($array[1])?$array[1]:'ASC';
if(array_key_exists($field,$this->mapFields)){
// 需要处理映射字段
$field = $this->mapFields[$field];
}
$_order[] = $field.' '.$sort;
}
$order = implode(',',$_order);
}
return $order;
}
/**
* 检查Group表达式中的聚合字段
* @access protected
* @param string $group 字段
* @return string
*/
protected function checkGroup($group='') {
if(!empty($group)) {
$groups = explode(',',$group);
$_group = array();
foreach ($groups as $field){
// 解析成聚合字段
if(array_key_exists($field,$this->mapFields)){
// 需要处理映射字段
$field = $this->mapFields[$field];
}
$_group[] = $field;
}
$group = implode(',',$_group);
}
return $group;
}
/**
* 检查fields表达式中的聚合字段
* @access protected
* @param string $fields 字段
* @return string
*/
protected function checkFields($fields='') {
if(empty($fields) || '*'==$fields ) {
// 获取全部聚合字段
$fields = $this->fields;
}
if(!is_array($fields))
$fields = explode(',',$fields);
// 解析成聚合字段
$array = array();
foreach ($fields as $field){
if(array_key_exists($field,$this->mapFields)){
// 需要处理映射字段
$array[] = $this->mapFields[$field].' AS '.$field;
}else{
$array[] = $field;
}
}
$fields = implode(',',$array);
return $fields;
}
/**
* 获取数据表字段信息
* @access public
* @return array
*/
public function getDbFields(){
return $this->fields;
}
}