Model::reflesh() - Code Metrics - Inspection of "一些修正" - top-think/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — 6.0 ( 2a00ae...39e6cf )

by yun
created 2019-04-10 07:19 UTC
Model::reflesh() A

↳ Parent: Model
Complexity

Conditions	3
Paths	3
Size

Total Lines	12
Code Lines	6
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	12
Importance

Changes
Metric	Value
cc	3
eloc	6
nc	3
nop	1
dl	0
loc	12
ccs	0
cts	7
cp	0
crap	12
rs	10
c	0
b	0
f	0
<?php
// +----------------------------------------------------------------------

// | ThinkPHP [ WE CAN DO IT JUST THINK ]
// +----------------------------------------------------------------------
// | Copyright (c) 2006~2019 http://thinkphp.cn All rights reserved.
// +----------------------------------------------------------------------
// | Licensed ( http://www.apache.org/licenses/LICENSE-2.0 )
// +----------------------------------------------------------------------
// | Author: liu21st <[email protected]>
// +----------------------------------------------------------------------
declare (strict_types = 1);

namespace think;

use ArrayAccess;
use Closure;
use JsonSerializable;
use think\db\Query;

/**
 * Class Model
 * @package think

 * @mixin Query

 * @method Query where(mixed $field, string $op = null, mixed $condition = null) static 查询条件

 * @method Query whereTime(string $field, string $op, mixed $range = null) static 查询日期和时间

 * @method Query whereBetweenTime(string $field, mixed $startTime, mixed $endTime) static 查询日期或者时间范围

 * @method Query whereBetweenTimeField(string $startField, string $endField) static 查询当前时间在两个时间字段范围

 * @method Query whereYear(string $field, string $year = 'this year') static 查询某年

 * @method Query whereMonth(string $field, string $month = 'this month') static 查询某月

 * @method Query whereDay(string $field, string $day = 'today') static 查询某日

 * @method Query whereRaw(string $where, array $bind = []) static 表达式查询

 * @method Query whereExp(string $field, string $condition, array $bind = []) static 字段表达式查询

 * @method Query when(mixed $condition, mixed $query, mixed $otherwise = null) static 条件查询

 * @method Query join(mixed $join, mixed $condition = null, string $type = 'INNER') static JOIN查询

 * @method Query view(mixed $join, mixed $field = null, mixed $on = null, string $type = 'INNER') static 视图查询

 * @method Query with(mixed $with) static 关联预载入

 * @method Query count(string $field) static Count统计查询

 * @method Query min(string $field) static Min统计查询

 * @method Query max(string $field) static Max统计查询

 * @method Query sum(string $field) static SUM统计查询

 * @method Query avg(string $field) static Avg统计查询

 * @method Query field(mixed $field, boolean $except = false) static 指定查询字段

 * @method Query fieldRaw(string $field, array $bind = []) static 指定查询字段

 * @method Query union(mixed $union, boolean $all = false) static UNION查询

 * @method Query limit(mixed $offset, integer $length = null) static 查询LIMIT

 * @method Query order(mixed $field, string $order = null) static 查询ORDER

 * @method Query orderRaw(string $field, array $bind = []) static 查询ORDER

 * @method Query cache(mixed $key = null, integer $expire = null) static 设置查询缓存

 * @method mixed value(string $field) static 获取某个字段的值

 * @method array column(string $field, string $key = '') static 获取某个列的值

 * @method Model find(mixed $data = null) static 查询单个记录 不存在返回Null

 * @method Model findOrEmpty(mixed $data = null) static 查询单个记录 不存在返回空模型

 * @method \think\model\Collection select(mixed $data = null) static 查询多个记录

 * @method Model withAttr(array $name, \Closure $closure) 动态定义获取器

 */

abstract class Model implements JsonSerializable, ArrayAccess
{
    use model\concern\Attribute;
    use model\concern\RelationShip;
    use model\concern\ModelEvent;
    use model\concern\TimeStamp;
    use model\concern\Conversion;

    /**
     * 数据是否存在
     * @var bool
     */
    private $exists = false;


    /**
     * 是否强制更新所有数据
     * @var bool
     */
    private $force = false;


    /**
     * 是否Replace
     * @var bool
     */
    private $replace = false;


    /**
     * 更新条件
     * @var array
     */
    private $updateWhere;


    /**
     * 数据库配置
     * @var string
     */
    protected $connection;

    /**
     * 模型名称
     * @var string
     */
    protected $name;

    /**
     * 数据表名称
     * @var string
     */
    protected $table;

    /**
     * 写入自动完成定义
     * @var array
     */
    protected $auto = [];

    /**
     * 新增自动完成定义
     * @var array
     */
    protected $insert = [];

    /**
     * 更新自动完成定义
     * @var array
     */
    protected $update = [];

    /**
     * 初始化过的模型.
     * @var array
     */
    protected static $initialized = [];

    /**
     * 查询对象实例
     * @var Query
     */
    protected $queryInstance;

    /**
     * 软删除字段默认值
     * @var mixed
     */
    protected $defaultSoftDelete;

    /**
     * 全局查询范围
     * @var array
     */
    protected $globalScope = [];

    /**
     * 延迟保存信息
     * @var bool
     */
    private $lazySave = false;


    /**
     * Db对象
     * @var Db
     */
    protected $db;

    /**
     * 服务注入
     * @var Closure
     */
    protected static $maker;

    /**
     * 设置服务注入
     * @access public
     * @param Closure $maker

     * @return void
     */
    public static function maker(Closure $maker)
    {
        static::$maker = $maker;
    }

    /**
     * 设置Db对象
     * @access public
     * @param Db $db Db对象

     * @return void
     */
    public function setDb(Db $db)
    {
        $this->db = $db;
    }

    /**
     * 设置Connection信息
     * @access public
     * @param mixed $connection 数据库配置

     * @return void
     */
    public function setConnection($connection)
    {
        $this->connection = $connection;
    }

    /**
     * 获取Connection信息
     * @access public
     * @return string|array
     */
    public function getConnection()
    {
        return $this->connection;
    }

    /**
     * 架构函数
     * @access public
     * @param array $data 数据

     */
    public function __construct(array $data = [])
    {
        $this->data = $data;

        if (!empty($this->data)) {
            // 废弃字段
            foreach ((array) $this->disuse as $key) {
                if (array_key_exists($key, $this->data)) {
                    unset($this->data[$key]);
                }
            }
        }

        // 记录原始数据
        $this->origin = $this->data;

        if (empty($this->name)) {
            // 当前模型名
            $name       = str_replace('\\', '/', static::class);
            $this->name = basename($name);
        }

        if (static::$maker) {
            call_user_func(static::$maker, $this);
        }

        // 执行初始化操作
        $this->initialize();
    }

    /**
     * 获取当前模型名称
     * @access public
     * @return string
     */
    public function getName(): string
    {
        return $this->name;
    }

    /**
     * 创建新的模型实例
     * @access public
     * @param array $data  数据

     * @param mixed $where 更新条件

     * @return Model
     */
    public function newInstance(array $data = [], $where = null): Model
    {
        if (empty($data)) {
            return new static();
        }

        $model = (new static($data))->exists(true);
        $model->setUpdateWhere($where);

        $model->trigger('after_read');

        return $model;
    }

    /**
     * 设置模型的更新条件
     * @access protected
     * @param mixed $where 更新条件

     * @return void
     */
    protected function setUpdateWhere($where): void
    {
        $this->updateWhere = $where;
    }

    /**
     * 设置当前模型的数据库查询对象
     * @access public
     * @param Query $query 查询对象实例

     * @return $this
     */
    public function setQuery(Query $query)
    {
        $this->queryInstance = clone $query;
        return $this;
    }

    /**
     * 获取当前模型的数据库查询对象
     * @access public
     * @param array|false $scope 使用的全局查询范围

     * @return Query
     */
    public function db($scope = []): Query
    {
        /** @var Query $query */

        if ($this->queryInstance) {
            $query = $this->queryInstance->removeOption();
        } else {
            $query = $this->db->buildQuery($this->connection)
                ->name($this->name)
                ->pk($this->pk);
        }

        $query->model($this)
            ->json($this->json, $this->jsonAssoc)
            ->setFieldType($this->schema);

        if (!empty($this->table)) {
            $query->table($this->table);
        }

        // 软删除
        if (property_exists($this, 'withTrashed') && !$this->withTrashed) {

            $this->withNoTrashed($query);
                   withNoTrashed($query);
        }

        // 全局作用域
        $globalScope = is_array($scope) && !empty($scope) ? $scope : $this->globalScope;

        if (!empty($globalScope) && false !== $scope) {
            $query->scope($globalScope);
        }

        // 返回当前模型的数据库查询对象
        return $query;
    }

    /**
     *  初始化模型
     * @access private
     * @return void
     */
    private function initialize(): void

    {
        if (!isset(static::$initialized[static::class])) {
            if ($this->observerClass) {
                // 注册模型观察者
                static::observe($this->observerClass);
            }
            static::$initialized[static::class] = true;
            static::init();
        }
    }

    /**
     * 初始化处理
     * @access protected
     * @return void
     */
    protected static function init(): void
    {
    }

    /**
     * 数据自动完成
     * @access protected
     * @param array $auto 要自动更新的字段列表

     * @return void
     */
    protected function autoCompleteData(array $auto = []): void
    {
        foreach ($auto as $field => $value) {
            if (is_integer($field)) {
                $field = $value;
                $value = null;
            }

            if (!isset($this->data[$field])) {
                $default = null;
            } else {
                $default = $this->data[$field];
            }

            $this->setAttr($field, !is_null($value) ? $value : $default);
        }
    }

    protected function checkData(): void

    {
    }

    protected function checkResult($result): void

    {
    }

    /**
     * 更新是否强制写入数据 而不做比较
     * @access public
     * @param bool $force

     * @return $this
     */
    public function force(bool $force = true)
    {
        $this->force = $force;
        return $this;
    }

    /**
     * 判断force
     * @access public
     * @return bool
     */
    public function isForce(): bool
    {
        return $this->force;
    }

    /**
     * 新增数据是否使用Replace
     * @access public
     * @param bool $replace

     * @return $this
     */
    public function replace(bool $replace = true)
    {
        $this->replace = $replace;
        return $this;
    }

    /**
     * 刷新模型数据
     * @access public
     * @param bool $relation 是否刷新关联数据

     * @return $this
     */
    public function refresh(bool $relation = false)
    {
        if ($this->exists) {
            $this->data   = $this->db()->fetchArray()->find($this->getKey());

            $this->origin = $this->data;


            if ($relation) {
                $this->relation = [];
            }
        }

        return $this;
    }

    /**
     * 设置数据是否存在
     * @access public
     * @param bool $exists

     * @return $this
     */
    public function exists(bool $exists = true)
    {
        $this->exists = $exists;
        return $this;
    }

    /**
     * 判断数据是否存在数据库
     * @access public
     * @return bool
     */
    public function isExists(): bool
    {
        return $this->exists;
    }

    /**
     * 判断模型是否为空
     * @access public
     * @return bool
     */
    public function isEmpty(): bool
    {
        return empty($this->data);
    }

    /**
     * 延迟保存当前数据对象
     * @access public
     * @param array|bool $data 数据

     * @return void
     */
    public function lazySave($data = []): void
    {
        if (false === $data) {
            $this->lazySave = false;
        } else {
            if (is_array($data)) {
                $this->setAttrs($data);
            }

            $this->lazySave = true;
        }
    }

    /**
     * 保存当前数据对象
     * @access public
     * @param array  $data     数据

     * @param string $sequence 自增序列名

     * @return bool
     */
    public function save(array $data = [], string $sequence = null): bool
    {
        // 数据对象赋值
        $this->setAttrs($data);

        if ($this->isEmpty() || false === $this->trigger('before_write')) {
            return false;
        }

        $result = $this->exists ? $this->updateData() : $this->insertData($sequence);

        if (false === $result) {
            return false;
        }

        // 写入回调
        $this->trigger('after_write');

        // 重新记录原始数据
        $this->origin   = $this->data;
        $this->set      = [];
        $this->lazySave = false;

        return true;
    }

    /**
     * 检查数据是否允许写入
     * @access protected
     * @param array $append 自动完成的字段列表

     * @return array
     */
    protected function checkAllowFields(array $append = []): array
    {
        // 检测字段
        if (empty($this->field)) {
            if (!empty($this->schema)) {
                $this->field = array_keys($this->schema);
            } else {
                $query = $this->db();
                $table = $this->table ?: $query->getTable();

                $this->field = $query->getConnection()->getTableFields($table);
            }

            return $this->field;
        }

        $field = array_merge($this->field, $append);

        if ($this->autoWriteTimestamp) {
            array_push($field, $this->createTime, $this->updateTime);
        }

        if (!empty($this->disuse)) {
            // 废弃字段
            $field = array_diff($field, $this->disuse);
        }

        return $field;
    }

    /**
     * 保存写入数据
     * @access protected
     * @return bool
     */
    protected function updateData(): bool
    {
        // 自动更新
        $auto = array_merge($this->auto, $this->update);

        $this->autoCompleteData($auto);

        // 事件回调
        if (false === $this->trigger('before_update')) {
            return false;
        }

        $this->checkData();

        // 获取有更新的数据
        $data = $this->getChangedData();

        if (empty($data)) {
            // 关联更新
            if (!empty($this->relationWrite)) {
                $this->autoRelationUpdate();
            }

            return false;
        }

        if ($this->autoWriteTimestamp && $this->updateTime && !isset($this->data[$this->updateTime])) {
            // 自动写入更新时间
            $this->data[$this->updateTime] = $this->autoWriteTimestamp($this->updateTime);
            $this->data[$this->updateTime] = $this->autoWriteTimestamp(/** @scrutinizer ignore-type */ $this->updateTime);
            $data[$this->updateTime]       = $this->data[$this->updateTime];
        }

        // 检查允许字段
        $allowFields = $this->checkAllowFields($auto);

        foreach ($this->relationWrite as $name => $val) {
            if (!is_array($val)) {
                continue;
            }

            foreach ($val as $key) {
                if (isset($data[$key])) {
                    unset($data[$key]);
                }
            }
        }

        // 模型更新
        $db = $this->db();
        $db->startTrans();

        try {
            $where  = $this->getWhere();
            $result = $db->where($where)
                ->strict(false)
                ->field($allowFields)
                ->update($data);

            $this->checkResult($result);

            // 关联更新
            if (!empty($this->relationWrite)) {
                $this->autoRelationUpdate();
            }

            $db->commit();

            // 更新回调
            $this->trigger('after_update');

            return true;
        } catch (\Exception $e) {
            $db->rollback();
            throw $e;
        }
    }

    /**
     * 新增写入数据
     * @access protected
     * @param string $sequence 自增名

     * @return bool
     */
    protected function insertData(string $sequence = null): bool
    {
        // 自动写入
        $auto = array_merge($this->auto, $this->insert);

        $this->autoCompleteData($auto);

        // 时间戳自动写入
        if ($this->autoWriteTimestamp) {
            if ($this->createTime && !isset($this->data[$this->createTime])) {
                $this->data[$this->createTime] = $this->autoWriteTimestamp($this->createTime);
                $this->data[$this->createTime] = $this->autoWriteTimestamp(/** @scrutinizer ignore-type */ $this->createTime);
            }

            if ($this->updateTime && !isset($this->data[$this->updateTime])) {
                $this->data[$this->updateTime] = $this->autoWriteTimestamp($this->updateTime);
            }
        }

        if (false === $this->trigger('before_insert')) {
            return false;
        }

        $this->checkData();

        // 检查允许字段
        $allowFields = $this->checkAllowFields($auto);

        $db = $this->db();
        $db->startTrans();

        try {
            $result = $db->strict(false)
                ->field($allowFields)
                ->replace($this->replace)
                ->insert($this->data, false, $sequence);
                ->/** @scrutinizer ignore-call */ insert($this->data, false, $sequence);

            // 获取自动增长主键
            if ($result && $insertId = $db->getLastInsID($sequence)) {
                $pk = $this->getPk();

                foreach ((array) $pk as $key) {
                    if (!isset($this->data[$key]) || '' == $this->data[$key]) {
                        $this->data[$key] = $insertId;
                    }
                }
            }

            // 关联写入
            if (!empty($this->relationWrite)) {
                $this->autoRelationInsert();
            }

            $db->commit();

            // 标记数据已经存在
            $this->exists = true;

            // 新增回调
            $this->trigger('after_insert');

            return true;
        } catch (\Exception $e) {
            $db->rollback();
            throw $e;
        }
    }

    /**
     * 获取当前的更新条件
     * @access public
     * @return mixed
     */
    public function getWhere()
    {
        $pk = $this->getPk();

        if (is_string($pk) && isset($this->data[$pk])) {
            $where = [[$pk, '=', $this->data[$pk]]];
        } elseif (!empty($this->updateWhere)) {
            $where = $this->updateWhere;
        } else {
            $where = null;
        }

        return $where;
    }

    /**
     * 保存多个数据到当前数据对象
     * @access public
     * @param iterable $dataSet 数据

     * @param boolean  $replace 是否自动识别更新和写入

     * @return Collection
     * @throws \Exception
     */
    public function saveAll(iterable $dataSet, bool $replace = true): Collection
    {
        $db = $this->db();
        $db->startTrans();

        try {
            $pk = $this->getPk();

            if (is_string($pk) && $replace) {
                $auto = true;
            }

            $result = [];

            foreach ($dataSet as $key => $data) {
                if ($this->exists || (!empty($auto) && isset($data[$pk]))) {
                    $result[$key] = self::update($data, $this->field);
                } else {
                    $result[$key] = self::create($data, $this->field, $this->replace);
                }
            }

            $db->commit();

            return $this->toCollection($result);
        } catch (\Exception $e) {
            $db->rollback();
            throw $e;
        }
    }

    /**
     * 删除当前的记录
     * @access public
     * @return bool
     */
    public function delete(): bool
    {
        if (!$this->exists || $this->isEmpty() || false === $this->trigger('before_delete')) {
            return false;
        }

        // 读取更新条件
        $where = $this->getWhere();

        $db = $this->db();
        $db->startTrans();

        try {
            // 删除当前模型数据
            $db->where($where)->delete();

            // 关联删除
            if (!empty($this->relationWrite)) {
                $this->autoRelationDelete();
            }

            $db->commit();

            $this->trigger('after_delete');

            $this->exists   = false;
            $this->lazySave = false;

            return true;
        } catch (\Exception $e) {
            $db->rollback();
            throw $e;
        }
    }

    /**
     * 设置自动完成的字段（ 规则通过修改器定义）
     * @access public
     * @param array $fields 需要自动完成的字段

     * @return $this
     */
    public function auto(array $fields)
    {
        $this->auto = $fields;

        return $this;
    }

    /**
     * 写入数据
     * @access public
     * @param array $data       数据数组

     * @param array $allowField 允许字段

     * @param bool  $replace    使用Replace

     * @return static
     */
    public static function create(array $data, array $allowField = [], bool $replace = false): Model
    {
        $model = new static();

        if (!empty($allowField)) {
            $model->allowField($allowField);
        }

        $model->replace($replace)->save($data);

        return $model;
    }

    /**
     * 更新数据
     * @access public
     * @param array $data       数据数组

     * @param mixed $where      更新条件

     * @param array $allowField 允许字段

     * @return static
     */
    public static function update(array $data, $where = [], array $allowField = [])
    {
        $model = new static();

        if (!empty($allowField)) {
            $model->allowField($allowField);
        }

        if (!empty($where)) {
            $model->setUpdateWhere($where);
        }

        $model->exists(true)->save($data);

        return $model;
    }

    /**
     * 删除记录
     * @access public
     * @param mixed $data  主键列表 支持闭包查询条件

     * @param bool  $force 是否强制删除

     * @return bool
     */
    public static function destroy($data, bool $force = false): bool
    {
        if (empty($data) && 0 !== $data) {
            return false;
        }

        $model = new static();

        $query = $model->db();

        if (is_array($data) && key($data) !== 0) {
            $query->where($data);
            $data = null;
        } elseif ($data instanceof \Closure) {
            $data($query);
            $data = null;
        }

        $resultSet = $query->select($data);

        foreach ($resultSet as $result) {
            $result->force($force)->delete();
        }

        return true;
    }

    /**
     * 解序列化后处理
     */

    public function __wakeup()
    {
        $this->initialize();
    }

    public function __debugInfo()

    {
        return [
            'data'     => $this->data,
            'relation' => $this->relation,
        ];
    }

    /**
     * 修改器 设置数据对象的值
     * @access public
     * @param string $name  名称

     * @param mixed  $value 值

     * @return void
     */
    public function __set(string $name, $value): void
    {
        $this->setAttr($name, $value);
    }

    /**
     * 获取器 获取数据对象的值
     * @access public
     * @param string $name 名称

     * @return mixed
     */
    public function __get(string $name)
    {
        return $this->getAttr($name);
    }

    /**
     * 检测数据对象的值
     * @access public
     * @param string $name 名称

     * @return bool
     */
    public function __isset(string $name): bool
    {
        return !is_null($this->getAttr($name));
    }

    /**
     * 销毁数据对象的值
     * @access public
     * @param string $name 名称

     * @return void
     */
    public function __unset(string $name): void
    {
        unset($this->data[$name], $this->relation[$name]);
    }

    // ArrayAccess
    public function offsetSet($name, $value)

    {
        $this->setAttr($name, $value);
    }

    public function offsetExists($name): bool

    {
        return $this->__isset($name);
    }

    public function offsetUnset($name)

    {
        $this->__unset($name);
    }

    public function offsetGet($name)

    {
        return $this->getAttr($name);
    }

    /**
     * 设置使用的全局查询范围
     * @access public
     * @param array|false $scope 启用的全局查询范围

     * @return Query
     */
    public static function useGlobalScope($scope)
    {
        $model = new static();

        return $model->db($scope);
    }

    public function __call($method, $args)

    {
        if ('withattr' == strtolower($method)) {
            return call_user_func_array([$this, 'withAttribute'], $args);
        }

        return call_user_func_array([$this->db(), $method], $args);
    }

    public static function __callStatic($method, $args)

    {
        $model = new static();

        return call_user_func_array([$model->db(), $method], $args);
    }

    /**
     * 析构方法
     * @access public
     */
    public function __destruct()
    {
        if ($this->lazySave) {
            $this->save();
        }
    }
}

top-think / framework

Push — 6.0 ( 2a00ae...39e6cf )

Model::reflesh() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
