ThinkPHP自定义无限极分类demo

实例方法

namespace app\comm\controller;
/*
 * @Author: Lance Ma
 * @LastEditors: Please set LastEditors
 * @Description: In User Settings Edit
 * @FilePath: .\application\comm\controller\sales.php
 */

use think\Controller;
use think\Request;
use think\Db;

class sales extends Comm {
    // 分佣配置
    private $virtual_currency_type = [
        1 => 0, // 静态值
        2 => 0 // 动态值
    ];
    private $base_dict = [1 => 399];
    private $rate_dict = [1 => [5], 2 => [15], 3 => [15], 4 => [5], 5 => [8]];
    private $team_award_dict = [1 => [0, 0], 2 => [0, 1], 3 => [0, 3, 2], 4 => [0, 5, 3], 5 => [0, 5, 3]];
    private $cultivate_dict = [1 => [0, 0], 2 => [0, 0], 3 => [0, 0, 0], 4 => [0, 10, 5], 5 => [0, 10, 5]];
    // 1-保证金，2-返利, 3-团队, 4-培育，5-分红
    private $rebate_dict = [
        1 => 'deposit',
        2 => 'rebate',
        3 => 'group',
        4 => 'cultivate',
        5 => 'dividends'
    ];

    public function _initialize() {
        $this->timestamp = time();
        // 初始化函数
        parent::_initialize();
        
        // 校验用户是否登录
        if (empty($this->uid) || intval($this->uid) < 1) {
            // exit(json_encode(['data' => null, 'errmsg' => '当前用户未登录或者不存在！', 'errcode' => 100403]));
        }
    }

    /**
     *  合作中心
     *  @param  
     *  @return  Json
    */
        
    public function index(Request $request) {
        $param  = $request->param();
        extract($param);
        $user = self::check_user($this->uid);
        if (empty(Db::name('sales')->where('uid', $this->uid)->count('uid'))) {
            $create_sales = $this->create_sales(['uid' => $this->uid]);
            if ($create_sales[0] !== 1) {
                return self::export_json(null, $create_sales[1], 100400);
            }
            $user = array_merge($user, ['performance' => 0, 'income' => 0]);
        } else {
            $sales = Db::name('sales')->field(['performance', 'income'])->where('uid', $this->uid)->find();
            $user = array_merge($user, [
                'performance' => (int)$sales['performance'],
                'income' => (int)$sales['income']
            ]);
        }
        $ad = Db::name('poster')->field('p_id  as id, p_name as name, p_picture_addr as pic')->where(['p_type' => 10])->find();
        if (!empty($ad) && !empty($ad['pic'])) {
            $ad['pic'] = unserialize($ad['pic']);
        }
        
        $data = [
            'user' => $user,
            'ad' => $ad
        ];
        return self::export_json($data, '数据查询成功！', 100200);
    }

    /**
     *  创建(更新)用户分销数据
     *  @param  
     *  $uid  用户id
     *  $grade 分销等级
     *  @return  Array
    */
        
    public function create_sales($array = [], $update = false) {

        if ($update) {
            if (empty($array)) {
                return [0, '当前更新数据为空或者不存在！'];
            }
            if (empty(Db::name('sales')->where('uid', $this->uid)->count('uid'))) {
                return [0, '当前更新表不存在或者已删除！'];
            }
            $array = array_merge($array, ['update_time' => $this->timestamp]);
            if (Db::name('sales')->where('uid', $this->uid)->update($array)) {
                return [1, '当前数据更新成功！'];
            }
            return [0, '当前数据更新失败！'];
        } else {
            $array = array_merge(['uid' => $this->uid], $array);
            if (!empty($array['list'])) {
                $list = [];
                foreach ($array['list'] as $k => $v) {
                    $list[] = [
                        'uid' => $v,
                        'create_time' => $this->timestamp,
                        'update_time' => $this->timestamp,
                    ];
                }
                $sqlAll = Db::name('sales')->insertAll($list);
                if (empty($sqlAll) || $sqlAll !== count($array['list'])) {
                    return [0, '创建分销用户表失败！'];
                }
            } else {
                if (empty($array['uid'])) {
                    return [0, '创建分销用户(uid)为空！'];
                }
                if (Db::name('sales')->where('uid', $array['uid'])->count('uid')) {
                    return [1, '当前用户表已创建成功！'];
                }
                $data = array_merge([
                    'create_time' => $this->timestamp,
                    'update_time' => $this->timestamp,
                ], $array);
                if (empty(Db::name('sales')->insertGetId($data))) {
                    return [0, '创建分销用户表失败！'];
                }
            }
            return [1, '创建分销用户表成功！'];
        }
    }


    /**
     *  分销计算
     *  @param  
     *  $money
     *  @return  JSON
    */
    public function brokerage(Request $request) {
        $param  = $request->param();
        extract($param);
        if (empty($money)) {
            return self::export_json(null, '当前分佣金额(money)为空！', 100400);
        }
        if (empty($uid) || intval($uid) < 1) {
            return self::export_json(null, '当前订单用户(uid)为空！', 100400);
        }
        if (empty($oid)) {
            return self::export_json(null, '当前订单(oid)为空！', 100400);
        }
        $select_sql = $grade_array = [];
        $mine_sql = Db::name('member')
                    ->field(['codes', 'code', 'grade_id as grade'])
                    ->where(['id' => $uid])->find();
        $grade_sql = Db::name('source_level_ratio')
                    ->field(['slr_id as id', 'slr_name as name', 'slr_cultivate as cultivate', 'slr_team_award as team_award', 'slr_rate as rate', 'slr_base as base'])
                    ->where(['slr_state' => 0])->order('id asc')->select();
        foreach ($grade_sql as $k => $v) {
            // $this->base_dict[$v['id']] = [$v['base']];
            // $this->rate_dict[$v['id']] = [$v['rate']];
            // $this->team_award_dict[$v['id']] = [$v['team_award']];
            // $this->cultivate_dict[$v['id']] = [$v['cultivate']];
            
            $grade_array[$v['id']] = $v;
        }
        if (!empty($mine_sql) && !empty($mine_sql['codes'])) {
            $mine_code = $mine_sql['codes'];
            if ($mine_code) {
                $select_sql = $this->getRelativeNetwork($mine_code, $uid);
            }
            
        }
        $list_depth = $list_data = $grade_list = $sweep_list = [];
        $counter = 0;
        $mine_grade = $mine_sql['grade'];

        // 添加分销表中不存在用户
        $uid_array = array_column($select_sql, 'uid');
        $uid_null = array_diff(
                        $uid_array,
                        array_column(
                            Db::name('sales')->field(['uid'])->where('uid','in', $uid_array)->select(),
                            'uid'
                    ));
        if (!empty($uid_null)) {
            $create_sales = $this->create_sales(['list' => $uid_null]);
            if ($create_sales[0] !== 1) {
                return self::export_json(null, $create_sales[1], 100400);
            }
        }
        
        // 计算当前会员 分佣比例
        foreach ($this->rate_dict as $k => $v) {
            if ($mine_grade >= $k) {
                $grade_list[] = array_sum($v);
            }
        }
        // 分佣起始计算(比例)
        $this->rate_dict[$mine_grade][0] = array_sum($grade_list);
        // 清理数据（上级）
        foreach ($select_sql as $k => $v) {
            $son_grade = !empty($select_sql[$k - 1]) ? $select_sql[$k - 1]['grade'] : $v['grade'];
            if ($son_grade <= $v['grade']) {
                $sweep_list[] = $v;
            }
        }
        // 会员线等级排序
        foreach ($sweep_list as $k => $v) {
           $list_depth[$v['grade']][] = $v['grade'];
        }
        // 计算相关佣金
        foreach ($sweep_list as $k => $v) {
            $team_award = $earnings = $cultivate = 0;
            $grade = $v['grade'];
            $depth = count($list_depth[$grade]);
            $rate = $this->rate_dict[$grade];
            $son_grade = !empty($sweep_list[$k - 1]) ? $sweep_list[$k - 1]['grade'] : $grade;
            $parent_grade = !empty($sweep_list[$k + 1]) ? $sweep_list[$k + 1]['grade'] : $grade;
            // 返利奖
            if (!empty($rate[$counter])) {
                $earnings = round($money * $rate[$counter] / 100, 2);
                if (!empty($this->base_dict[$grade]) && $earnings > $this->base_dict[$grade]) {
                    $earnings = $this->base_dict[$grade];
                }
            }
            // 团队奖
            if (!empty($this->team_award_dict[$grade]) && !empty($this->team_award_dict[$grade][$counter])) {
                $team_award = round($money * $this->team_award_dict[$grade][$counter] / 100, 2);
            }
            // 培育奖
            if (!empty($this->cultivate_dict[$grade]) && !empty($this->cultivate_dict[$grade][$counter])) {
                $cultivate = round($rate[0] * $this->cultivate_dict[$grade][$counter], 2);
            }
            
            $list = array_merge($v, [
                'son_grade_id' => $son_grade,
                'parent_grade_id' => $parent_grade,
                'grade_name' => $grade_array[$grade]['name'],
                'counter' => $counter,
                'depth' => $depth,
                'funds' => [
                    $this->rebate_dict[2] => $earnings,
                    $this->rebate_dict[3] => $team_award,
                    $this->rebate_dict[4] => $cultivate
                ]
                
                ,$grade_array[$grade]['name'] => [
                    '分佣奖' => $earnings,
                    '团队奖' => $team_award,
                    '培育奖' => $cultivate
                ]
            ]);

            $counter = $counter >= $depth - 1 ? 0 : $counter + 1;
            
            $list_data[] = $list;
        }
        // 释放数组内存
        unset($list_depth, $grade_list, $sweep_list);

        // 整理分销流水表
        $flowing_water = [];
        foreach ($list_data as $k => $v) {
            foreach($v['funds'] as $x => $y) {
                if (!empty($y)) {
                    $flowing_water[] = [
                        'uid' => $v['uid'],
                        'oid' => $oid,
                        'grade' => $v['grade'],
                        'type' => array_search($x, $this->rebate_dict),
                        'money' => $y,
                        'create_time' => $this->timestamp
                    ];
                }
            }
        }
        if ($this->create_flowing_water($flowing_water)) {
            return self::export_json(null, '当前分销流水创建成功！', 100200);
        }
        return self::export_json(null, '当前分销流水创建失败！', 100400);
  
        


        return self::export_json($list_data, '当前分销计算成功成功！', 100200);
        
        // id 主键， uid 用户id，tid 上级(线)id，level 用户等级，commission 佣金，rebate 返利
        $demo_data = [
            'level_dict' => $this->level_dict,
            'rate_dict' => $this->rate_dict,
            'team_award_dict' => $this->team_award_dict,
            'cultivate_dict' => $this->cultivate_dict
        ];

        // 储存配置文件
        // file_put_contents("./test.json", json_encode($demo_data));
        
        $json_string = json_decode(file_get_contents("./test.json"), true);
        return self::export_json($json_string, '配置查询成功！', $errcode = 100200);

    }

    /**
     *  分佣储存
     *  @param  
     *          $money
     *  @return  JSON
    */
    public function create_flowing_water($array = []) {
        $array_length = count($array);
        if ($array_length < 1) {
            return 0;
        }
        if ($this->arrayLevel($array) > 1) {
            $sqlAll = Db::name('earnings')->insertAll($array);
            if (empty($sqlAll) || $sqlAll !== $array_length) {
                return 0;
            }
        } else {
            if (empty(Db::name('earnings')->insertGetId($array))) {
                return 0;
            }
        }
        return 1;
    }

    /**
     *  会员关系查询
     *  @param  
     *          $money
     *  @return  Array
    */
    public function getRelativeNetwork($code, $pid, $asc = true, $list = []) {
        if ($asc) {
            $select_sql = Db::name('member')
                        ->field(['id as uid', 'code as code', 'nickname as nick_name', 'grade_id as grade'])
                        ->where(['codes' => $code])
                        ->find();
            if (!empty($select_sql)) {
                $select_sql = array_merge($select_sql, ['pid' => $pid]);
                array_push($list, $select_sql);
                $son_sql = $this->getRelativeNetwork($select_sql['code'], $select_sql['uid'], $asc);
                if (!empty($son_sql)) {
                    $list = array_merge($list, $son_sql);
                }
            }
        }else {

            $select_sql = Db::name('member')
                        ->field(['id as uid', 'code as code', 'nickname as nick_name', 'grade_id as grade'])
                        ->where(['codes' => $code])
                        ->select();
                        
            if (!empty($select_sql)) {
                
            }
        }
        
        return $list;
    }

    /**
     * 返回数组的维度
     */
    public function arrayLevel($array = [])  {
        $length = [];
        function arrayDeep($array, &$length, $level = 0) {
            if(is_array($array)){
                $level++;
                $length[] = $level;
                foreach($array as $v){
                    arrayDeep($v, $length, $level);
                }
            }
        }
        arrayDeep($array, $length);
        return max($length);
    }

    /**
     *  查询用户信息
     *  @param  $uid   查询用户id
     *  @return  Array
     */
    public static function check_user($uid) {
        if (empty($uid)) {
            return [];
        }
        $member = new Member();
        $user = $member->return_member_info($uid);
        return [
            'uid' => $user['data']['id'],
            'name' => $user['data']['nickname'],
            'avatar_url' => $user['data']['image'],
            'signature' => $user['data']['ignature'],
            'sex' => $user['data']['sex']
        ];
    }

    /**
     *  自定义数据JSON数据，请参考原方法
     *  @include
    */
    public static function export_json($export_data = null, $errmsg = '数据操作成功！', $errcode = 100200) {
        if ($errmsg === 'Array') {
            return $export_data;
        }
        return parent::json_data($errcode, $errmsg, 0, $export_data, true);
        exit;
    }

}