tp框架自定义模型增删改查公共方法

2021-09-26

控制器

<?php

// 自定义继承自Exception的类
use VerifyException;

/**
 * @description: 列表操作
 */
trait Lists
{
    // 列表
    public function list()
    {
        $validate = new $this->validate;
        $model    = new $this->model;
        $param = $this->request->param();

        if (!$validate->scene('list')->check($param)) {
            return errorRetuen($validate->getError());
        };
        $where = $this->listWhere($param);
        $data = $model->pages($where, $param);
        $data['data'] = $this->dealList($data['data']);
        return successRetuen('查询成功', $data);
    }

    // 添加/修改数据
    public function create()
    {
        $validate = new $this->validate;
        $model    = new $this->model;
        $param = $this->request->param();
        if (!$validate->scene('create')->check($param)) {
            return errorRetuen($validate->getError());
        };

        try {
            if (hasValue($param, 'id')) {
                $object = $model->getObjetcByID($param['id']);
                $this->verifyObject($object);
            } else {
                $object = false;
            }
            $this->createVerify($param);
        } catch (VerifyException $e) {
            return errorRetuen($e->getMessage());
        }
        
        $id = $model->createData($param, $this->user, $object);
        return successRetuen('保存完成', ['id' => $id]);
    }

    // 查看单条
    public function info()
    {
        $validate = new $this->validate;
        $model    = new $this->model;
        $param = $this->request->param();
        if (!$validate->scene('id')->check($param)) {
            return errorRetuen($validate->getError());
        };
        $object = $this->dealInfo($model->getInfo($param['id']));
        return successRetuen('查询成功', $object);
    }

    /**
     * @description: 处理列表数据
     * @param array $datas
     * @return array
     */
    protected function dealList($datas){return $datas;}

    /**
     * @description: 处理单条数据
     * @param Collection $datas
     * @return array|Collection
     */
    protected function dealInfo($datas){return $datas;}

    /**
     * @description: 验证模型是否允许提交，不允许则抛出VerifyException异常
     * @param Model $model
     * @return array|Collection
     */
    protected function verifyObject($model){}

    /**
     * @description: 验证数据是否为模型允许保存数据，不允许则抛出VerifyException异常
     * @param array $param
     * @return boid
     */
    protected function createVerify($param){}
}

模型

<?php

use think\Model;

class Base extends Model
{
    /**
     * @description: 前端参数
     * @var array
     */
    protected $param = [];

     /**
     * @description: 根据条件获取数据集
     * @param array $where 查询条件
     * @param string $field 查询字段
     * @param array $order 排序
     * @return {*}
     */
    public function getDatasByWhere($where, $field = '*', $order = [])
    {
        return $this->where($where)->order($order)->field($field)->select();
    }

    /**
     * @description: 根据条件获取单条数据
     * @param array $where 查询条件
     * @param string $field 查询字段
     * @param array $order 排序
     * @param bool $isValue 使用是否value方法
     * @return {*}
     */
    public function getDataByWhere($where, $field = '*', $order = [])
    {
        return $this->where($where)->order($order)->field($field)->find();
    }

    /**
     * @description: 根据条件使用column方法获取数据集数组
     * @param array $where 查询条件
     * @param string $field 查询字段
     * @param array $order 排序
     * @return array
     */
    public function getDatasColumn($where, $field = '*', $order = [])
    {
        $key = explode(',', $field)[0];
        return $this->where($where)->order($order)->column($field, $key);
    }

    /**
     * @description: 根据条件使用value方法获取数据
     * @param array $where 查询条件
     * @param string $field 查询字段
     * @param array $order 排序
     * @return {*}
     */
    public function getDataValue($where, $field = '*', $order = [])
    {
        return $this->where($where)->order($order)->value($field);
    }

    /**
     * @description: 分页查询
     * @param array $where 查询条件
     * @param array $param 前端数据
     * @return {*}
     */
    public function pages($where, $param)
    {
        $this->param = $param;
        return $this->with($this->pageWith())->where($where)->order($this->pageOrder())
                ->field($this->pageField())->append($this->pageAppend())
                ->paginate(pageParam($param))->toArray();
    }

    /**
     * @description: 列表页预加载数据
     * @param {*}
     * @return array
     */
    protected function pageWith()
    {
        return [];
    }

    /**
     * @description: 列表页查询字段
     * @param {*}
     * @return string
     */
    protected function pageField()
    {
        return '*';
    }

    /**
     * @description: 列表页查询追加字段
     * @param {*}
     * @return array
     */
    protected function pageAppend()
    {
        return [];
    }

    /**
     * @description: 列表页排序规则
     * @param {*}
     * @return array
     */
    protected function pageOrder()
    {
        return ['create_time' => 'desc'];
    }

    /**
     * @description: 根据主键一条数据的详细信息
     * @param int $id 主键
     * @return {*}
     */
    public function getInfo($id)
    {
        return $this->with($this->infoWith())->field($this->infoField())->where('id', $id)->find($id);
    }

    /**
     * @description: 单条数据预加载数据
     * @param {*}
     * @return array
     */
    protected function infoWith()
    {
        return [];
    }

    /**
     * @description: 单条数据查询字段
     * @param {*}
     * @return string
     */
    protected function infoField()
    {
        return '*';
    }
    
    /**
     * @description: 保存数据
     * @param array $param 前端数据
     * @param array $user 用户信息
     * @param Model|false $model 模型
     * @return int 返回主键
     */
    public function createData($param, $user, $model = false)
    {
        $this->param = $param;
        $this->user  = $user;
        $data              = $this->createDatas();
        $data['update_by'] = $user['id'];
        
        if ($model && $model instanceof Model) {
            $model->save($data);
        } else {
            $data['create_by'] = $user['id'];
            $model             = static::create($data);
        }
        $this->createOther($model);
        return $model[$this->pk];
    }

    /**
     * @description: 模型需要保存的数据 
     * @param {*}
     * @return {*}
     */
    protected function createDatas(){}

    /**
     * @description: 保存数据后的其他操作
     * @param Model $model 实例化的模型
     * @return void
     */
    protected function createOther($model){}

    /**
     * @description: 关联数据处理
     * @param Model $relevance 关联对象
     * @param array $data 前端传的数据
     * @param string $field 关联表数据的字段名
     * @return {*}
     */
    protected function relevanceSave($relevance, $data, $field)
    {
        $original = $relevance->column($field);
        $del      = array_diff($original, $data);
        $add      = array_diff($data, $original);

        if ($del) {
            $relevance->where($field, 'in', $del)->delete();
        }
        if ($add) {
            $adds = [];
            foreach ($add as $val) {
                $adds[] = [$field => $val];
            }
            $relevance->saveAll($adds);
        }
    }

    /**
     * @description: 关联数据处理，关联数据有多字段处理
     * @param Model $relevance 关联对象
     * @param array $data 前端传的数据
     * @param array $fields [数据表字段名=>前端传的字段名]
     * @param array $extras 扩展数据
     * @return {*}
     */
    protected function relevanceSaves($relevance, $data, $fields, $extras = [])
    {
        $original = $relevance->column('id');
        $chuan    = [];
        $add      = [];
        foreach ($data as $val) {
            if (!hasValue($val, 'id')) {
                $data = [];
                foreach ($fields as $bfield => $cfield) {
                    $data[$bfield] = $val[$cfield] ?? '';
                }
                $add[] = array_merge($data, $extras);
            } else {
                $chuan[] = $val['id'];
            }
        }
        if ($add) {
            $relevance->saveAll($add);
        }
        if ($del = array_diff($original, $chuan)) {
            $relevance->where('id', 'in', $del)->delete();
        }
    }

    /**
     * @description: 根据主键获取一条数据
     * @param int $id 主键
     * @return {*}
     */
    public function getObjetcByID($id)
    {
        return $this->find($id);
    }
}

查询条件拼接

/**
 * @description 判断数组中是否包含指定键且值不为空
 * @param array $param 前端数据
 * @param string $field 查询键名
 * @return bool
 */
function hasValue($param, $field)
{
    return isset($param[$field]) && !empty($param[$field]) ? true : false;
}

/**
 * @description: 查询条件数据处理
 * @param string $op 查询表达式
 * @param string $field 查询字段名
 * @param array $data 查询数据
 * @return {*}
 */
function conditionData($op, $field, ...$data)
{
    switch ($op) {
        case 'like':
            return [$field, $op, '%' . $data[0] . '%'];
        case 'between':
            return [$field, $op, $data];
        default:
            return [$field, $op, $data[0]];
    }
}

/**
 * @description: 拼接查询条件
 * @param array $where 查询条件
 * @param array $param 前端数据
 * @param string $field1 查询键名
 * @param string $field2 前端数据键名
 * @param string $op 查询表达式
 * @return {*}
 */
function conditionQuery(&$where, $param, $field1, $field2, $op)
{
    if (hasValue($param, $field2)) {
        $where[] = conditionData($op, $field1, $param[$field2]);
    }
}


/**
 * @description: 时间查询条件
 * @param array $where 查询条件
 * @param array $param 前端数据
 * @param string $field1 查询开始时间字段名
 * @param string $field2 查询结束时间字段名
 * @param string $field 查询字段名
 * @return {*}
 */
function conditionTime(&$where, $param, $field1, $field2, $field)
{
    if (hasValue($param, $field1) && hasValue($param, $field2)) {
        $where[] = conditionData('between', $field, $param[$field1], $param[$field2]);
    } elseif (hasValue($param, $field1)) {
        $where[] = conditionData('>=', $field, $param[$field1]);
    } elseif (hasValue($param, $field2)) {
        $where[] = conditionData('<=', $field, $param[$field2]);
    }
}

 

CATALOG
标签
tp框架 php 基础知识 php 三方库 php文档操作 swoole workerman
{/if}