mirror of
https://gitee.com/fastadminnet/framework.git
synced 2026-07-01 12:42:48 +08:00
492 lines
18 KiB
PHP
492 lines
18 KiB
PHP
<?php
|
|
// +----------------------------------------------------------------------
|
|
// | ThinkPHP [ WE CAN DO IT JUST THINK ]
|
|
// +----------------------------------------------------------------------
|
|
// | Copyright (c) 2006~2016 http://thinkphp.cn All rights reserved.
|
|
// +----------------------------------------------------------------------
|
|
// | Licensed ( http://www.apache.org/licenses/LICENSE-2.0 )
|
|
// +----------------------------------------------------------------------
|
|
// | Author: liu21st <liu21st@gmail.com>
|
|
// +----------------------------------------------------------------------
|
|
|
|
namespace traits\model;
|
|
|
|
use think\Lang;
|
|
|
|
trait Auto
|
|
{
|
|
/**
|
|
* 创建数据对象 但不保存到数据库
|
|
* @access public
|
|
* @param mixed $data 创建数据
|
|
* @param string $type 状态
|
|
* @return mixed
|
|
*/
|
|
public function create($data = '', $type = '')
|
|
{
|
|
// 如果没有传值默认取POST数据
|
|
if (empty($data)) {
|
|
$data = \think\Input::post();
|
|
} elseif (is_object($data)) {
|
|
$data = get_object_vars($data);
|
|
}
|
|
// 验证数据
|
|
if (empty($data) || !is_array($data)) {
|
|
$this->error = Lang::get('_DATA_TYPE_INVALID_');
|
|
return false;
|
|
}
|
|
$pk = $this->getPk();
|
|
// 状态
|
|
$type = $type ? $type : (is_string($pk) && !empty($data[$pk]) ? self::MODEL_UPDATE : self::MODEL_INSERT);
|
|
$type = 1 << ($type - 1);
|
|
// 字段列表
|
|
$keys = array_keys($data);
|
|
|
|
// 检测提交字段的合法性
|
|
if (isset($this->options['field'])) {
|
|
// $this->field('field1,field2...')->create()
|
|
$fields = $this->options['field'];
|
|
unset($this->options['field']);
|
|
} elseif (self::MODEL_INSERT == $type && isset($this->insertFields)) {
|
|
$fields = $this->insertFields;
|
|
} elseif (self::MODEL_UPDATE == $type && isset($this->updateFields)) {
|
|
$fields = $this->updateFields;
|
|
}
|
|
if (isset($fields)) {
|
|
if (is_string($fields)) {
|
|
$fields = explode(',', $fields);
|
|
}
|
|
// 判断令牌验证字段
|
|
if (Config::get('token_on')) {
|
|
$fields[] = Config::get('token_name');
|
|
}
|
|
|
|
foreach ($keys as $i => $key) {
|
|
if (!in_array($key, $fields)) {
|
|
unset($keys[$i]);
|
|
unset($data[$key]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 数据自动验证
|
|
if (!$this->_autoValidation($data, $type)) {
|
|
return false;
|
|
}
|
|
|
|
// 验证完成生成数据对象
|
|
if (empty($this->options['link'])) {
|
|
// 开启字段检测并且没有关联表 则过滤非法字段数据
|
|
$fields = $this->getFields();
|
|
foreach ($keys as $i => $key) {
|
|
if (!in_array($key, $fields)) {
|
|
unset($data[$key]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 创建完成对数据进行自动处理
|
|
$this->_autoOperation($data, $type);
|
|
// 验证后的回调方法
|
|
$this->_after_create($data, $this->options);
|
|
// 赋值当前数据对象
|
|
$this->data = $data;
|
|
// 返回创建的数据以供其他调用
|
|
return $data;
|
|
}
|
|
|
|
// 创建数据对象后的回调方法
|
|
protected function _after_create(&$data, $options)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* 使用正则验证数据
|
|
* @access public
|
|
* @param string $value 要验证的数据
|
|
* @param string $rule 验证规则
|
|
* @return boolean
|
|
*/
|
|
public function regex($value, $rule)
|
|
{
|
|
static $validate = [
|
|
'require' => '/.+/',
|
|
'email' => '/^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$/',
|
|
'url' => '/^http(s?):\/\/(?:[A-za-z0-9-]+\.)+[A-za-z]{2,4}(?:[\/\?#][\/=\?%\-&~`@[\]\':+!\.#\w]*)?$/',
|
|
'currency' => '/^\d+(\.\d+)?$/',
|
|
'number' => '/^\d+$/',
|
|
'zip' => '/^\d{6}$/',
|
|
'integer' => '/^[-\+]?\d+$/',
|
|
'double' => '/^[-\+]?\d+(\.\d+)?$/',
|
|
'english' => '/^[A-Za-z]+$/',
|
|
];
|
|
// 检查是否有内置的正则表达式
|
|
if (isset($validate[strtolower($rule)])) {
|
|
$rule = $validate[strtolower($rule)];
|
|
}
|
|
return preg_match($rule, $value) === 1;
|
|
}
|
|
|
|
/**
|
|
* 自动表单处理
|
|
* @access public
|
|
* @param array $data 创建数据
|
|
* @param string $type 创建类型
|
|
* @return mixed
|
|
*/
|
|
protected function _autoOperation(&$data, $type)
|
|
{
|
|
if (isset($this->options['auto'])) {
|
|
if (false === $this->options['auto']) {
|
|
// 关闭自动完成
|
|
return;
|
|
} else {
|
|
$_auto = $this->options['auto'];
|
|
unset($this->options['auto']);
|
|
if (empty($_auto) && !empty($this->auto)) {
|
|
$_auto = $this->auto;
|
|
}
|
|
}
|
|
} elseif (!empty($this->auto)) {
|
|
$_auto = $this->auto;
|
|
}
|
|
// 自动填充
|
|
if (!empty($_auto)) {
|
|
foreach ($_auto as $key => $val) {
|
|
if (!is_numeric($key) && is_array(current($val)) && isset($data[$key])) {
|
|
foreach ($val as $k => $v) {
|
|
$this->_operationField($data[$key], $v, $type);
|
|
}
|
|
} else {
|
|
$this->_operationField($data, $val, $type);
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* 填充表单字段
|
|
* @access private
|
|
* @param array $data 创建数据
|
|
* @param array $auto 填充因子
|
|
* @param string $type 创建类型
|
|
* @return boolean
|
|
*/
|
|
private function _operationField(&$data, &$auto, $type)
|
|
{
|
|
// 填充因子定义格式
|
|
// array('field','填充内容','填充时间','附加规则',[额外参数])
|
|
if (empty($auto[2])) {
|
|
$flags = 1 << (self::MODEL_INSERT - 1);
|
|
} elseif (is_array($auto[2])) {
|
|
$flags = 0;
|
|
foreach ($auto[2] as $v) {
|
|
$flags |= 1 << ($v - 1);
|
|
}
|
|
} else {
|
|
$flags = 3 == $auto[2] ? 3 : 1 << ($auto[2] - 1);
|
|
}
|
|
// 检查填充条件
|
|
if ($flags & $type) {
|
|
if (empty($auto[3])) {
|
|
$auto[3] = 'string';
|
|
}
|
|
switch (trim($auto[3])) {
|
|
case 'function':// 使用函数进行填充 字段的值作为参数
|
|
case 'callback': // 使用回调方法
|
|
$args = isset($auto[4]) ? (array) $auto[4] : [];
|
|
if (is_string($auto[0]) && strpos($auto[0], ',')) {
|
|
$auto[0] = explode(',', $auto[0]);
|
|
}
|
|
if (is_array($auto[0])) {
|
|
// 支持多个字段验证
|
|
foreach ($auto[0] as $field) {
|
|
$_data[$field] = isset($data[$field]) ? $data[$field] : null;
|
|
}
|
|
array_unshift($args, $_data);
|
|
} else {
|
|
array_unshift($args, isset($data[$auto[0]]) ? $data[$auto[0]] : null);
|
|
}
|
|
if ('function' == $auto[3]) {
|
|
$data[$auto[0]] = call_user_func_array($auto[1], $args);
|
|
} else {
|
|
$data[$auto[0]] = call_user_func_array([ & $this, $auto[1]], $args);
|
|
}
|
|
break;
|
|
case 'field': // 用其它字段的值进行填充
|
|
$data[$auto[0]] = $data[$auto[1]];
|
|
break;
|
|
case 'ignore': // 为空忽略
|
|
if ($auto[1] === $data[$auto[0]]) {
|
|
unset($data[$auto[0]]);
|
|
}
|
|
break;
|
|
case 'string':
|
|
default: // 默认作为字符串填充
|
|
$data[$auto[0]] = $auto[1];
|
|
}
|
|
if (isset($data[$auto[0]]) && false === $data[$auto[0]]) {
|
|
unset($data[$auto[0]]);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 自动表单验证
|
|
* @access protected
|
|
* @param array $data 创建数据
|
|
* @param string $type 创建类型
|
|
* @return boolean
|
|
*/
|
|
protected function _autoValidation(&$data, $type)
|
|
{
|
|
if (isset($this->options['validate'])) {
|
|
if (false === $this->options['validate']) {
|
|
// 关闭自动验证
|
|
return true;
|
|
} else {
|
|
$_validate = $this->options['validate'];
|
|
unset($this->options['validate']);
|
|
if (empty($_validate) && !empty($this->validate)) {
|
|
$_validate = $this->validate;
|
|
}
|
|
}
|
|
} elseif (!empty($this->validate)) {
|
|
$_validate = $this->validate;
|
|
}
|
|
// 属性验证
|
|
if (!empty($_validate)) {
|
|
// 如果设置了数据自动验证则进行数据验证
|
|
if ($this->patchValidate) {
|
|
// 重置验证错误信息
|
|
$this->error = [];
|
|
}
|
|
foreach ($_validate as $key => $val) {
|
|
if (!is_numeric($key) && is_array(current($val)) && isset($data[$key])) {
|
|
foreach ($val as $k => $v) {
|
|
if (false === $this->_validationField($data[$key], $v, $type)) {
|
|
return false;
|
|
}
|
|
}
|
|
} else {
|
|
if (false === $this->_validationField($data, $val, $type)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
// 批量验证的时候最后返回错误
|
|
if (!empty($this->error)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* 验证表单字段 支持批量验证
|
|
* 如果批量验证返回错误的数组信息
|
|
* @access protected
|
|
* @param array $data 创建数据
|
|
* @param array $val 验证因子
|
|
* @param string $type 创建类型
|
|
* @return boolean
|
|
*/
|
|
protected function _validationField(&$data, &$val, $type)
|
|
{
|
|
// 如果是批量验证,并且当前字段已经有规则验证没有通过则跳过
|
|
if ($this->patchValidate && isset($this->error[$val[0]])) {
|
|
return true;
|
|
}
|
|
// 验证因子定义格式
|
|
// [field,rule,message,condition,type,when,params]
|
|
if (empty($val[5])) {
|
|
$flags = 1 << (self::MODEL_BOTH - 1);
|
|
} elseif (is_array($val[5])) {
|
|
$flags = 0;
|
|
foreach ($val[5] as $v) {
|
|
$flags |= 1 << ($v - 1);
|
|
}
|
|
} else {
|
|
$flags = 3 == $val[5] ? 3 : 1 << ($val[5] - 1);
|
|
}
|
|
// 判断是否需要执行验证
|
|
if ($flags & $type) {
|
|
if (0 == strpos($val[2], '{%') && strpos($val[2], '}')) {
|
|
// 支持提示信息的多语言 使用 {%语言定义} 方式
|
|
$val[2] = Lang::get(substr($val[2], 2, -1));
|
|
}
|
|
$val[3] = isset($val[3]) ? $val[3] : self::EXISTS_VALIDATE;
|
|
$val[4] = isset($val[4]) ? $val[4] : 'regex';
|
|
$status = true;
|
|
// 判断验证条件
|
|
switch ($val[3]) {
|
|
case self::MUST_VALIDATE: // 必须验证 不管表单是否有设置该字段
|
|
$status = $this->_validationFieldItem($data, $val);
|
|
break;
|
|
case self::VALUE_VALIDATE: // 值不为空的时候才验证
|
|
if ('' != trim($data[$val[0]])) {
|
|
$status = $this->_validationFieldItem($data, $val);
|
|
}
|
|
break;
|
|
default: // 默认表单存在该字段就验证
|
|
if (isset($data[$val[0]])) {
|
|
$status = $this->_validationFieldItem($data, $val);
|
|
}
|
|
}
|
|
if (false === $status) {
|
|
if ($this->patchValidate) {
|
|
$this->error[$val[0]] = $val[2];
|
|
} else {
|
|
$this->error = $val[2];
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* 根据验证因子验证字段
|
|
* @access protected
|
|
* @param array $data 创建数据
|
|
* @param array $val 验证因子
|
|
* @return boolean
|
|
*/
|
|
protected function _validationFieldItem($data, $val)
|
|
{
|
|
switch (strtolower(trim($val[4]))) {
|
|
case 'function':// 使用函数进行验证
|
|
case 'callback': // 调用方法进行验证
|
|
$args = isset($val[6]) ? (array) $val[6] : [];
|
|
if (is_string($val[0]) && strpos($val[0], ',')) {
|
|
$val[0] = explode(',', $val[0]);
|
|
}
|
|
if (is_array($val[0])) {
|
|
// 支持多个字段验证
|
|
foreach ($val[0] as $field) {
|
|
$_data[$field] = isset($data[$field]) ? $data[$field] : null;
|
|
}
|
|
array_unshift($args, $_data);
|
|
} else {
|
|
array_unshift($args, isset($data[$val[0]]) ? $data[$val[0]] : null);
|
|
}
|
|
return call_user_func_array('function' == $val[4] ? $val[1] : [ & $this, $val[1]], $args);
|
|
case 'confirm': // 验证两个字段是否相同
|
|
return $data[$val[0]] == $data[$val[1]];
|
|
case 'unique': // 验证某个值是否唯一
|
|
if (is_string($val[0])) {
|
|
$val[0] = explode(',', $val[0]);
|
|
}
|
|
$map = [];
|
|
if (is_array($val[0])) {
|
|
// 支持多个字段验证
|
|
foreach ($val[0] as $field) {
|
|
if (!isset($data[$field])) {
|
|
return false;
|
|
}
|
|
$map[$field] = $data[$field];
|
|
}
|
|
}
|
|
$pk = $this->getPk();
|
|
if (!empty($data[$pk]) && is_string($pk)) {
|
|
// 完善编辑的时候验证唯一
|
|
$map[$pk] = ['neq', $data[$pk]];
|
|
}
|
|
$options = $this->options;
|
|
if ($this->where($map)->find()) {
|
|
return false;
|
|
}
|
|
$this->options = $options;
|
|
return true;
|
|
default: // 检查附加规则
|
|
return $this->check($data[$val[0]], $val[1], $val[4]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 验证数据 支持 in between equal length regex expire ip_allow ip_deny
|
|
* @access public
|
|
* @param string $value 验证数据
|
|
* @param mixed $rule 验证表达式
|
|
* @param string $type 验证方式 默认为正则验证
|
|
* @return boolean
|
|
*/
|
|
public function check($value, $rule, $type = 'regex')
|
|
{
|
|
$type = strtolower(trim($type));
|
|
switch ($type) {
|
|
case 'in':// 验证是否在某个指定范围之内 逗号分隔字符串或者数组
|
|
case 'notin':
|
|
$range = is_array($rule) ? $rule : explode(',', $rule);
|
|
return 'in' == $type ? in_array($value, $range) : !in_array($value, $range);
|
|
case 'between':// 验证是否在某个范围
|
|
case 'notbetween': // 验证是否不在某个范围
|
|
if (is_array($rule)) {
|
|
$min = $rule[0];
|
|
$max = $rule[1];
|
|
} else {
|
|
list($min, $max) = explode(',', $rule);
|
|
}
|
|
return 'between' == $type ? $value >= $min && $value <= $max : $value < $min || $value > $max;
|
|
case 'equal':// 验证是否等于某个值
|
|
case 'notequal': // 验证是否等于某个值
|
|
return 'equal' == $type ? $value == $rule : $value != $rule;
|
|
case 'length': // 验证长度
|
|
$length = mb_strlen($value, 'utf-8'); // 当前数据长度
|
|
if (strpos($rule, ',')) {
|
|
// 长度区间
|
|
list($min, $max) = explode(',', $rule);
|
|
return $length >= $min && $length <= $max;
|
|
} else {
|
|
// 指定长度
|
|
return $length == $rule;
|
|
}
|
|
case 'expire':
|
|
list($start, $end) = explode(',', $rule);
|
|
if (!is_numeric($start)) {
|
|
$start = strtotime($start);
|
|
}
|
|
if (!is_numeric($end)) {
|
|
$end = strtotime($end);
|
|
}
|
|
return NOW_TIME >= $start && NOW_TIME <= $end;
|
|
case 'ip_allow': // IP 操作许可验证
|
|
return in_array($_SERVER['REMOTE_ADDR'], explode(',', $rule));
|
|
case 'ip_deny': // IP 操作禁止验证
|
|
return !in_array($_SERVER['REMOTE_ADDR'], explode(',', $rule));
|
|
case 'filter': // 使用filter_var验证
|
|
$result = filter_var($value, is_int($rule) ? $rule : filter_id($rule));
|
|
return false === $result ? false : true;
|
|
case 'regex':
|
|
default: // 默认使用正则验证 可以使用验证类中定义的验证名称
|
|
// 检查附加规则
|
|
return $this->regex($value, $rule);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 指定自动完成
|
|
* @access public
|
|
* @param array $auto 自动完成设置
|
|
* @return Auto
|
|
*/
|
|
public function auto($auto = [], $rule = null)
|
|
{
|
|
$this->options['auto'] = $auto;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* 指定自动验证
|
|
* @access public
|
|
* @param array $validate 自动验证设置
|
|
* @return Auto
|
|
*/
|
|
public function validate($validate = [], $rule = null)
|
|
{
|
|
$this->options['validate'] = $validate;
|
|
return $this;
|
|
}
|
|
}
|