sports_admin/app/Http/Controllers/Api/WriteSportsController.php

<?php
/**
 * Created by PhpStorm.
 * User: Jun.peng
 * Date: 2019/5/13
 * Time: 10:19
 */
namespace App\Http\Controllers\Api;
use Illuminate\Routing\Controller as BaseController;
use App\Http\Response\Response;
use Illuminate\Http\Request as Req;
use Illuminate\Support\Facades\DB;
use App\Lib\Biz\Sport\Common as commonFunction;
use App\Http\Model\StBqResult as BqResultModel;
use App\Http\Model\StBroadcast as broadcastModel;
use App\Http\Model\StGameType as gameModel;
use App\Http\Model\StLqResult as LqResultModel;
use App\Http\Model\StWqResult as WqResultModel;
use App\Http\Model\StZqLocalLeague as LeagueModel;
use App\Http\Model\StZqLocalMatch as MatchModel;
use App\Http\Model\StZqOdds as OddsModel;
use App\Http\Model\StZqOddsRecord as OddsRecordModel;
use App\Http\Model\StZqResult as ZqResultModel;
use App\Http\Model\St_area_country as StAreaCountryModel;
use App\Http\Model\St_set_sports_record  as St_set_sports_recordModel;




/**
 * 体育数据入库接口
 */
class WriteSportsController extends BaseController{

    /*
     * 用户 用户 token
     */
    public function getToken(Req $req){
        if ($req->isMethod('post')) {
            $user = new \App\Models\System_user;
            $str = $user->adminLogin($_POST['account'], $_POST['password']);
            if($str>0){
                $token=refreshToken($str['admin_id']);
                $str['token']=$token;
                $data = $str;
                $req->session()->put('adminInfo',$str);
                $str=1;
            }
            $log = array(
                session('adminInfo.admin_name'),
                $_POST['account']
            );
            OperationLog(session('adminInfo.admin_id'), 'login', $log);
            return Response::success($data);
        }
    }

    /**
     * 根据联赛名称 获取 国家 地区
     */
    public function getArea($leagueName = ''){
        //如果联赛名称有括号，去除
        $leagueName = preg_replace('/\(.*?\)/', '', $leagueName);

        //获取所有国家/地区
        $areaData = StAreaCountryModel::select('id','pid','name')->get()->toArray();
    
        //获取当前联赛所属国家
        if(strpos($leagueName,'NBA') !== false){
            $data = [
                'id'=>247,
                'pid'=>0,
                'name'=>'世界'
            ];
            return $data;
        }
        //识别本地 国家地区数据
        foreach($areaData as $v => $k){
            if(strpos($leagueName,$k['name']) !== false){ 
                return $k;
            }
        }

        //如果不能识别，则返回世界
        $data = [
            'id'=>247,
            'pid'=>0,
            'name'=>'世界'
        ];
        return $data;
    }

    /*
     * 写 联赛 数据
     * 每个请求 包含 N个联赛
     */
    public function setLeague(Req $data){
        //验证token
        $user = new \App\Models\System_user;
        if(empty($data->token)) return Response::generate('未获取到token',Response::TOKEN_ERR);
        $token = $user::where(['token'=>$data->token])->value('token');
        if(empty($token)) return Response::generate('token验证不通过',Response::TOKEN_ERR);
        try {
            //开启事务
            DB::beginTransaction();
            $obt = $data->data;
            //请求 数据 为空
            if(empty($obt)) throw new \Exception(Response::generate('请求数据为空，',Response::ABNORMAL));
            $getData = $this->getAddData($obt);
            //不是 联赛 数据
            if($getData['title'] != 'league') throw new \Exception(Response::generate('不是联赛数据，',Response::ABNORMAL));
            
            /*
            //写请求数据 日志记录
            $setSportsRecord = St_set_sports_recordModel::setSportsRecord($getData['title'],$obt,$getData);
            if($setSportsRecord < 1) throw new \Exception(Response::generate('',Response::SPORTS_RECORD_ERR));
            */

             //获取球类代码
             $game_code = $getData['game_code'];
             //获取数据源
             $source = $getData['source'];
             //获取球类名称
             $gameName = gameModel::getGameName($game_code);
 
             //获取 model
             $models = commonFunction::getModels($game_code, 1);
 
             //获取 联赛 数据
             $leagueData = $getData['data'];


             //获取 当前请求 所有 联赛 uuid
             $identity = [];
             foreach($leagueData as $k=>$v){
                $identity[] = $v['uuid'];
             }
             $identity = array_unique($identity);
             sort($identity);

             //获取 本地 已存在 联赛
             $l_lg_data = $models['model_local_league']::whereIn('identity',$identity)->select('identity','lg_id')->get()->toArray();
             //二维数组去重
             $l_lg_data = commonFunction::uniquArrV2($l_lg_data,'identity');
             //循环对比 请求identity->本地identity 
             foreach($l_lg_data as $k=>$v){
                 foreach($identity as $kk=> $uuid){
                     if($v['identity'] == $uuid){
                         unset($identity[$kk]);
                     }
                 }
             }
             //去除本地和请求里都存在的联赛，如果还有剩余联赛uuid,则将其写入
             if(!empty($identity)) {
                 //没有 决赛时间 默认获取本年最后一天
                 $last_time = date('Y-12-31 23:59:59');
                foreach($leagueData as $k=>$v){
                    foreach($identity as $kk=> $uuid){
                        if($v['uuid'] == $uuid){
                            //如有 决赛时间
                            if($v['last_time']){
                                $last_time = $v['last_time'];
                            }
                            //获取联赛所属国家或地区
                            $getArea = $this->getArea($v['name_chinese']);
                            if($getArea['pid'] == 0){
                                $area_id = $getArea['id'];
                                $country_id = 0;
                            }else{
                                $area_id = $getArea['pid'];
                                $country_id = $getArea['id'];
                            }
                            if(empty($v['uuid'])) throw new \Exception(Response::generate($gameName.'联赛-lg_id:'.$v['lg_id'].';',Response::LG__UUID_NULL));
                            $set_lg['name_chinese'] = $v['name_chinese'];
                            $set_lg['kind'] = $v['kind'];
                            $set_lg['match_mode'] = $v['match_mode'];
                            $set_lg['if_stop'] = $v['if_stop'];
                            $set_lg['identity'] = $v['uuid'];
                            $set_lg['last_time'] = $last_time;
                            $set_lg['utime'] = date('Y-m-d H:i:s');
                            $set_lg['area_id'] = $area_id;
                            $set_lg['country_id'] = $country_id;
                            //写入联赛
                            $id = $models['model_league']::insertGetId($set_lg);
                            $m_lg_id = $id;
                            if($m_lg_id < 1) throw new \Exception(Response::generate($gameName.'联赛-lg_id:'.$v['lg_id'].';',Response::INSERT_ERROR));
                         
                            //写入 本地 联赛记录
                            $set_local = [
                                'lg_id'=>$id,
                                'others_lg_id'=>$v['lg_id'],
                                'source'=>$source,
                                'ctime'=>date('Y-m-d H:i:s'),
                                'identity'=>$v['uuid'],
                            ];
                            $ret = $models['model_local_league']::insertGetId($set_local);
                            if($ret < 1) throw new \Exception(Response::generate($gameName.'联赛-lg_id:'.$data['lg_id'].';',Response::LOCAL_LEAGUE_ERROR)) ;//Render([], '10017', lang('Tips','Sports')->get('local_league_error'));

                        }
                    }
                }
             }

             //提交事务
             DB::commit();
             return Response::success();
         } catch (\Exception $e) {
             //回滚事务
             DB::rollBack();
             return $e->getMessage();
         }
    }

    /*
     * 写 赛事 数据
     * 每个请求 包含 N个联赛 下 N个赛事
     */
    public function setMatch(Req $data){
        //验证token
        $user = new \App\Models\System_user;
        if(empty($data->token)) return Response::generate('未获取到token',Response::TOKEN_ERR);
        $token = $user::where(['token'=>$data->token])->value('token');
        if(empty($token)) return Response::generate('token验证不通过',Response::TOKEN_ERR);
        try {
            //开启事务
            DB::beginTransaction();
            $obt = $data->data;
            //请求 数据 为空
            if(empty($obt)) throw new \Exception(Response::generate('请求数据为空，',Response::ABNORMAL));
            $getData = $this->getAddData($obt);
            //不是 赛事 数据
            if($getData['title'] != 'match') throw new \Exception(Response::generate('不是赛事数据，',Response::ABNORMAL));

            /*
            //写请求数据 日志记录
            $setSportsRecord = St_set_sports_recordModel::setSportsRecord($getData['title'],$obt,$getData);
            if($setSportsRecord < 1) throw new \Exception(Response::generate('',Response::SPORTS_RECORD_ERR));
            */
            //获取球类代码
            $game_code = $getData['game_code'];
            //获取数据源
            $source = $getData['source'];
            //获取球类名称
            $gameName = gameModel::getGameName($game_code);
            //获取 model
            $models = commonFunction::getModels($game_code, 1);
            //获取 赛事 数据
            $matchData = $getData['data'];
            //获取 当前请求 所有 uuid
            $identity = [];
            $s_match_ids = [];
            foreach($matchData as $k=>$v){
                $identity[] = $v['uuid'];
                $s_match_ids[] = $v['match_id'];
            }

            //====验证 赛事 所属 联赛 是否存在====
            $identity = array_unique($identity);
            sort($identity);

            //获取 本地 已存在 联赛
            $l_lg_data = $models['model_local_league']::whereIn('identity',$identity)->select('identity','lg_id','others_lg_id')->get()->toArray();
            //二维数组去重
            $l_lg_data = commonFunction::uniquArrV2($l_lg_data,'identity');
            //如果获取不到本地联赛数据，则返回联赛不存在
            if(empty($l_lg_data)) throw new \Exception(Response::generate($gameName.'本次请求的所有赛事都没有联赛数据;',Response::LEAGUE_ERROR));
            
            //获取到本次请求，所有本地有联赛的赛事
            $mathData_before = $matchData;//接收原赛事
            $matchData = [];//获取新赛事
            foreach($l_lg_data as $k=>$v){
                foreach($mathData_before as $kk=>$vv){
                    if($v['identity'] == $vv['uuid']){
                        $matchData[] = $vv;
                    }
                }
            }
            //获取当前请求有关联联赛的赛事 match_id
            $s_match_ids = [];
            foreach($matchData as $k=>$v){
                $s_match_ids[] = $v['match_id'];
            }
            /*
            //循环对比 请求uuid->本地identity
            foreach($l_lg_data as $k=>$v){
                foreach($identity as $kk=> $uuid){
                    if($v['identity'] == $uuid){
                        unset($identity[$kk]);
                    }
                }
            }
            sort($identity);
            //去除本地和请求里都存在的联赛，如果还有剩余联赛id,则返回异常
            if(!empty($identity))  throw new \Exception(Response::generate($gameName.'联赛：uuid-'.$identity[0].';',Response::LEAGUE_ERROR));
            //如果有剩余联赛，则表示该赛事找不到联赛，将其删除
            if(!empty($identity)){
                foreach($matchData as $k=>$v){
                    foreach($identity as $kk=> $uuid){
                        if($v['uuid'] == $uuid){
                            unset($matchData[$k]);
                        }
                    }
                }
                sort($matchData);
            }
            //====end====
            */

            //====获取 本地 已存在 赛事====
            $s_match_ids = array_unique($s_match_ids);
            sort($s_match_ids);

            $l_match_data = $models['model_local_match']::whereIn('others_match_id',$s_match_ids)->where('source',$source)->select('others_match_id','match_id')->get()->toArray();
            //二维数组去重
            $l_match_data = commonFunction::uniquArrV2($l_match_data,'others_match_id');
        
            //循环对比 请求match_id->本地others_match_id 
            //如果本地有 赛事，则取出本地不存在赛事
            if(!empty($l_match_data)){
                foreach($l_match_data as $k=>$v){
                    foreach($s_match_ids as $kk=> $s_match_id){
                        if($v['others_match_id'] == $s_match_id){
                            unset($s_match_ids[$kk]);
                        }
                    }
                }
                sort($s_match_ids);
            }
           
            //剩余 赛事 数据 写入
            if(!empty($s_match_ids)){
                foreach($matchData as $k=>$v){
                    foreach($s_match_ids as $kk=> $s_match_id){
                        if($v['match_id'] == $s_match_id){
                            $data = $v;
                            $half_match_id = $v['half_match_id'];
                            //获取 本地 联赛 ID
                            //验证本赛事是否有数据源lg_id
                            if(empty($data['lg_id'])) throw new \Exception(Response::generate($gameName.'赛事-match_id:'.$data['match_id'].';',Response::S_LG_ID_NULL));
                            $lg_id = commonFunction::searcharray($data['uuid'],'identity',$l_lg_data,'lg_id');
                            //验证 本赛事是否获取到本地lg_id
                            if(empty($lg_id)) throw new \Exception(Response::generate($gameName.'赛事-match_id:'.$data['match_id'].';',Response::L_LG_ID_NULL));
                            /*
                            //如果有上半场赛事id 获取上半场赛事是否存在
                            if(!empty($l_match_data) and $data['half_match_id'] > 0){
                                $half_match_id = -1;
                                $half_match_id = $models['model_local_match']::where(['others_match_id'=>$data['half_match_id'],'source'=>$source])
                                    ->value('match_id');
                                if(empty($half_match_id)) throw new \Exception(Response::generate($gameName.'上半场赛事-match_id:'.$data['match_id'].';',Response::HALF_MATCH_ERROR)) ;//Render([], '10024', lang('Tips','Sports')->get('half_match_error'));
                            }
                            */
                            //如果赛事没有开始日期，则为冠军盘口赛事 
                            if(empty($data['match_date'])){
                                //冠军盘口赛事获取所属联赛结束时间
                                $last_time = $models['model_league']::where(['id'=>$lg_id])
                                    ->value('last_time');
                    
                                if(empty($last_time)) throw new \Exception(Response::generate($gameName.'联赛-lg_id:'.$data['lg_id'].';',Response::LG_LASTTIME_ERROR));//Render([], '10023', lang('Tips','Sports')->get('lg_lastTime_error'));
                                //给冠军盘口赛事 赋值时间
                                $time = strtotime($last_time);
                                $data['match_date'] = date('Y-m-d',$time);
                                $data['match_time'] = date('H:i:s',$time);
                            }
                            $set_match = [
                                'ctime'=>date('Y-m-d H:i:s'),
                                'utime'=>date('Y-m-d H:i:s'),
                                'expire_time'=>date('Y-m-d H:i:s',time()+60),
                                'home_team'=>$data['home_team']?:'',
                                'guest_team'=>$data['guest_team']?:'no_team',
                                'lg_id'=>$lg_id,
                                'status'=>$data['status'],
                                'match_date'=>$data['match_date']?:date('Y-m-d'),
                                'match_time'=>$data['match_time']?:date('H:i:s'),
                                // 'tag'=>$data['tag']?:0,
                                'is_rollball'=>$data['is_rollball']?:0,
                                'is_today'=>$data['is_today']?:0,
                                'is_morningplate'=>$data['is_morningplate']?:0,
                                'is_stringscene'=>$data['is_stringscene']?:0,
                                'us_time'=>$data['us_time']?:commonFunction::qgmdate('Y-m-d H:i:s', '', -4),
                                'half_match_id'=>$half_match_id?:0,
                                'identity' => $data['uuid'],
                            ];                           
                            //写入赛事 返回id
                            $id = $models['model_match']::insertGetId($set_match);
                            if($id < 1) throw new \Exception(Response::generate($gameName.'赛事-match_id:'.$data['match_id'].';',Response::INSERT_ERROR)) ;
                            
                            //写关联记录
                            $set_local = [
                                'match_id'=>$id,
                                'others_match_id'=>$data['match_id'],
                                'source'=>$source,
                                'ctime'=>date('Y-m-d H:i:s')
                            ];
                            $ret = $models['model_local_match']::insertGetId($set_local);
                            if($ret < 1) throw new \Exception(Response::generate($gameName.'赛事-match_id:'.$data['match_id'].';',Response::LOCAL_MATCH_ERROR)) ;//Render([], '10018', lang('Tips','Sports')->get('local_match_error'));
                        }
                    }
                }
            }
    
            //提交事务
            DB::commit();
            return Response::success();
        } catch (\Exception $e) {
            //回滚事务
            DB::rollBack();
            return $e->getMessage();
        }

    }

    /*
     * 写 赛事 结果 记录 数据
     * 每个请求 包含 N个联赛 下 N个赛事 结果数据
     */
    public function setMatchResult(Req $data){
        //验证token
        $user = new \App\Models\System_user;
        if(empty($data->token)) return Response::generate('未获取到token',Response::TOKEN_ERR);
        $token = $user::where(['token'=>$data->token])->value('token');
        if(empty($token)) return Response::generate('token验证不通过',Response::TOKEN_ERR);

        try {
            //开启事务
            DB::beginTransaction();
            $obt = $data->data;
            //请求 数据 为空
            if(empty($obt)) throw new \Exception(Response::generate('请求数据为空，',Response::ABNORMAL));
            $getData = $this->getAddData($obt);
            
            //不是 赛事 结果 记录 数据
            if($getData['title'] != 'match_result_r') throw new \Exception(Response::generate('不是赛事结果记录数据，',Response::ABNORMAL));

            /*
            //写请求数据 日志记录
            $setSportsRecord = St_set_sports_recordModel::setSportsRecord($getData['title'],$obt,$getData);
            if($setSportsRecord < 1) throw new \Exception(Response::generate('',Response::SPORTS_RECORD_ERR));
            */

            //获取球类代码
            $game_code = $getData['game_code'];
            //获取数据源
            $source = $getData['source'];
            //获取球类名称
            $gameName = gameModel::getGameName($game_code);
            //获取 model
            $models = commonFunction::getModels($game_code, 1);
            //获取 赛事 数据
            $match_r_data = $getData['data'];

            //获取 当前请求 所有 uuid /match_id
            $identity = [];
            $s_match_ids = [];
            foreach($match_r_data as $k=>$v){
                $identity[] = $v['uuid'];
                $s_match_ids[] = $v['match_id'];
            }

            //====验证 赛事 所属 联赛 是否存在====
            $identity = array_unique($identity);
            sort($identity);

            //获取 本地 已存在 联赛
            $l_lg_data = $models['model_local_league']::whereIn('identity',$identity)->select('identity','lg_id')->get()->toArray();
            //二维数组去重
            $l_lg_data = commonFunction::uniquArrV2($l_lg_data,'identity');
            //循环对比 请求uuid->本地identity
            foreach($l_lg_data as $k=>$v){
                foreach($identity as $kk=> $uuid){
                    if($v['identity'] == $uuid){
                        unset($identity[$kk]);
                    }
                }
            }
            sort($identity);
            //去除本地和请求里都存在的联赛，如果还有剩余联赛id,则返回异常
            if(!empty($identity))  throw new \Exception(Response::generate($gameName.'联赛：uuid-'.$identity[0].';',Response::LEAGUE_ERROR));
            //====end====

            //====验证 赛事结果记录 所属赛事 是否存在====
            $s_match_ids = array_unique($s_match_ids);
            sort($s_match_ids);

            //获取 本地 已存在 赛事
            $l_match_data = $models['model_local_match']::whereIn('others_match_id',$s_match_ids)->where('source',$source)->select('others_match_id','match_id')->get()->toArray();
            //二维数组去重
            $l_match_data = commonFunction::uniquArrV2($l_match_data,'others_match_id');
        
            //循环对比 请求match_id->本地others_match_id 
            foreach($l_match_data as $k=>$v){
                foreach($s_match_ids as $kk=> $s_match_id){
                    if($v['others_match_id'] == $s_match_id){
                        unset($s_match_ids[$kk]);
                    }
                }
            }
            sort($s_match_ids);
            //去除本地和请求里都存在的赛事，如果还有剩余赛事id,则返回异常
            if(!empty($s_match_ids))  throw new \Exception(Response::generate($gameName.'赛事-match_id'.$s_match_ids[0].';',Response::MATCH_ERROR));
            //====end====

            //处理 赛事 结果记录 数据
            foreach($match_r_data as $k=>$v){
                $data = $v;
                //获取 本地 联赛 ID
                $lg_id = commonFunction::searcharray($data['uuid'],'identity',$l_lg_data,'lg_id');
                //获取 本地 赛事 ID
                $match_id = commonFunction::searcharray($data['match_id'],'others_match_id',$l_match_data,'match_id');

                //根据球类 获取 赛事结果记录字段
                $set_match_r = $this->get_match_r($game_code,$lg_id,$match_id,$data);
                //写 赛事 结果 记录
                $ret = $models['model_result_record']::insert($set_match_r);
                if($ret != true) throw new \Exception(Response::generate($gameName.'赛事-match_id:'.$data['match_id'].';',Response::ADD_MATCH_R_R_ERROR));
            }

            //提交事务
            DB::commit();
            return Response::success();
        } catch (\Exception $e) {
            //回滚事务
            DB::rollBack();
            return $e->getMessage();
        }

    }

    /*
     * 写 普通 赔率 数据
     * 每个请求 只包含 一场赛事下 N条赔率
     */
    public function setOdds(Req $data){
        //验证token
        $user = new \App\Models\System_user;
        if(empty($data->token)) return Response::generate('未获取到token',Response::TOKEN_ERR);
        $token = $user::where(['token'=>$data->token])->value('token');
        if(empty($token)) return Response::generate('token验证不通过',Response::TOKEN_ERR);

        try {
            //开启事务
            DB::beginTransaction();
            $obt = $data->data;
            
            //请求 数据 为空
            if(empty($obt)) throw new \Exception(Response::generate('请求数据为空，',Response::ABNORMAL));
            $getData = $this->getAddData($obt);

            //不是 赔率 数据
            if($getData['title'] != 'odds') throw new \Exception(Response::generate('不是赔率数据，',Response::ABNORMAL));

            //写请求数据 日志记录
            $setSportsRecord = St_set_sports_recordModel::setSportsRecord($getData['title'],$obt,$getData);
            if($setSportsRecord < 1) throw new \Exception(Response::generate('',Response::SPORTS_RECORD_ERR));

            //获取球类代码
            $game_code = $getData['game_code'];
            //获取数据源
            $source = $getData['source'];
            //获取源数据联赛ID
            $uuid = $getData['uuid'];
            //获取源数据赛事ID
            $s_match_id = $getData['match_id'];
            //获取赔率所属赛事 tag 值 玩法数量
            $tag = $getData['tag']?:99;

            //获取球类名称
            $gameName = gameModel::getGameName($game_code);
            //验证本次请求所属联赛/赛事是否存在 返回本地联赛/赛事ID
            $models = commonFunction::getModels($game_code, 1);
            $lg_id = $this->leagueVerify($models,$uuid,$source,$gameName);
            $match_id = $this->matchVerify($models,$s_match_id,$source,$gameName);

            //更新赛事 tag 值
            //如果未获取到本地赛事id，则返回异常
            if(empty($match_id)) throw new \Exception(Response::generate($gameName.'赛事-match_id:'.$s_match_id.';',Response::L_MATCH_ID_ERR)) ;

            $upMatch = $models['model_match']::where(['id'=>$match_id])
            ->update(['tag'=>$tag,'utime'=>date('Y-m-d H:i:s')]);
            if($upMatch < 1) throw new \Exception(Response::generate($gameName.'赛事-match_id:'.$s_match_id.';',Response::UPMATCHTAG_ERROR)) ;

            //获取 赔率数据
            $oddsData = $getData['data'];
            //获取 当前 所有 可用 赔率 sole
            $odds_only = $getData['odds_only'];
            //更新赛事下所有 不在本次请求的赔率 状态
            $ret= OddsModel::upOddsStatus($models,$s_match_id,'',$source,$odds_only);
            if($ret != true) throw new \Exception(Response::generate($gameName,Response::ODDS_SOLE_ERR));

            //获取当前赛事 在本地的所有赔率
            $l_odds_data = $models['model_odds']::select('odds_only')->where(['match_id'=>$match_id])->get()->toArray();
            
            $set_odds_r = [];
            $set_odds = [];
            if(!empty($oddsData)){
                //去除本地已有的赔率
                if(!empty($l_odds_data)){
                    foreach($oddsData as $k=>$v){
                        foreach($l_odds_data as $kk=>$vv){
                            if($v['odds_only'] == $vv['odds_only']){
                                unset($oddsData[$k]);
                            }
                        }
                    }
                    sort($oddsData);
                }
                //处理待写入 赔率记录数据
                foreach($oddsData as $k=>$v){
                    //组装数据
                    $set_odds_r[] = [
                        'match_id'=> $match_id?:0,
                        'others_match_id'=> $v['match_id']?:0,
                        'odds_code'=> $v['odds_code']?:'',
                        'status'=> $v['status']?:0,
                        'sort'=> $v['sort']?:0,
                        'p_code'=> $v['p_code']?:'',
                        'odds'=> $v['odds']?:0,
                        'condition'=> $v['condition'],
                        'odds_only'=> $v['odds_only']?:'',
                        'source'=> $v['source']?:'',
                        'type'=> $v['type']?:0,
                        'team'=> $v['team']?:'',
                        'lg_id'=> $lg_id,
                        'others_lg_id'=> $v['lg_id'],
                        'ctime'=> date('Y-m-d H:i:s'),
                        'utime'=> date('Y-m-d H:i:s'),
                    ];
                }

                 //处理待写入 赔率数据
                 foreach($oddsData as $k=>$v){
                    //组装数据
                    $set_odds[] = [
                        'match_id'=> $match_id?:0,
                        'others_match_id'=> $v['match_id']?:0,
                        'odds_code'=> $v['odds_code']?:'',
                        'status'=> $v['status']?:0,
                        'sort'=> $v['sort']?:0,
                        'p_code'=> $v['p_code']?:'',
                        'odds'=> $v['odds']?:0,
                        'condition'=> $v['condition'],
                        'odds_only'=> $v['odds_only']?:'',
                        'source'=> $v['source']?:'',
                        'type'=> $v['type']?:0,
                        'team'=> $v['team']?:'',
                        'lg_id'=> $lg_id,
                        'others_lg_id'=> $v['lg_id'],
                        'ctime'=> date('Y-m-d H:i:s'),
                        'utime'=> date('Y-m-d H:i:s'),
                        'sole' => $v['sole'],
                        'expire_time' => date('Y-m-d H:i:s',time()+60)
                    ];
                }

                 //写赔率记录数据
                 $ret = $models['model_odds_record']::insert($set_odds_r);
                 if($ret != true) throw new \Exception(Response::generate($gameName.'赔率记录;',Response::ADD_ODDS_R_ERROR));
                 //写赔率 数据
                 $ret = $models['model_odds']::insert($set_odds);
                 if($ret != true) throw new \Exception(Response::generate($gameName.'赔率;',Response::ADD_ODDS_ERROR));
            }

            //提交事务                          
            DB::commit();
            return Response::success();
        } catch (\Exception $e) {
            //回滚事务
            DB::rollBack();
            return $e->getMessage();
        }
    }

    /*
    *写 冠军联赛 赔率 数据
    *每个请求 包含 N个联赛 下 N条赔率 
    */
    public function setOddsCH(Req $data){
        //验证token
        $user = new \App\Models\System_user;
        if(empty($data->token)) return Response::generate('未获取到token',Response::TOKEN_ERR);
        $token = $user::where(['token'=>$data->token])->value('token');
        if(empty($token)) return Response::generate('token验证不通过',Response::TOKEN_ERR);
        try {
            //开启事务
            DB::beginTransaction();
            $obt = $data->data;

            //请求 数据 为空
            if(empty($obt)) throw new \Exception(Response::generate('请求数据为空，',Response::ABNORMAL));
            $getData = $this->getAddData($obt);
            //不是 冠军 赔率 数据
            if($getData['title'] != 'odds_ch') throw new \Exception(Response::generate('不是冠军赔率数据，',Response::ABNORMAL));

            //写请求数据 日志记录
            $setSportsRecord = St_set_sports_recordModel::setSportsRecord($getData['title'],$obt,$getData);
            if($setSportsRecord < 1) throw new \Exception(Response::generate('',Response::SPORTS_RECORD_ERR));
            //获取球类代码
            $game_code = $getData['game_code'];
            //获取数据源
            $source = $getData['source'];
            //获取球类名称
            $gameName = gameModel::getGameName($game_code);

            //获取 model
            $models = commonFunction::getModels($game_code, 1);

            //获取 赔率数据
            $oddsData = $getData['data'];
            //获取 当前 所有 可用 赔率 sole
            $odds_only = $getData['odds_only'];

            //====验证 请求里 所有赔率 所属联赛 是否存在 ====
            //获取 当前请求 所有 联赛 uuid
            $uuids = [];
            $s_lg_ids = [];
            foreach($oddsData as $k=>$v){
                $uuids[] = $v['uuid'];
                $s_lg_ids[] = $v['lg_id'];
            }
            $s_lg_ids = array_unique($s_lg_ids);
            $uuids = array_unique($uuids);
            sort($uuids);
            sort($s_lg_ids);

            //更新联赛下所有 不在本次请求的赔率 状态
            $ret= OddsModel::upOddsStatus($models,'',$s_lg_ids,$source,$odds_only);
            if($ret != true) throw new \Exception(Response::generate($gameName,Response::ODDS_SOLE_ERR));

            //获取 本地 已存在 联赛
            $l_lg_data = $models['model_local_league']::whereIn('identity',$uuids)->select('identity','lg_id')->get()->toArray();
            //二维数组去重
            $l_lg_data = commonFunction::uniquArrV2($l_lg_data,'identity');
            //循环对比 请求uuid->本地uuid
            foreach($l_lg_data as $k=>$v){
                foreach($uuids as $kk=> $uuid){
                    if($v['identity'] == $uuid){
                        unset($uuids[$kk]);
                    }
                }
            }

            //去除本地和请求里都存在的联赛，如果还有剩余联赛id,则返回异常； 
            if(!empty($uuids))  throw new \Exception(Response::generate($gameName.'冠军联赛：uuid-'.$uuids[0].';',Response::LEAGUE_ERROR));
            //====end====
            
            //赔率记录数据
            $set_odds_r = [];
            //赔率数据
            $set_odds = [];
            if(!empty($oddsData)){
                foreach($oddsData as $k=>$v){ 
                    //获取 本地 联赛 ID
                    $lg_id = commonFunction::searcharray($v['uuid'],'identity',$l_lg_data,'lg_id');
                    //组装赔率记录数据
                    $set_odds_r[] = [
                        'match_id'=>0,
                        'others_match_id'=> $v['match_id']?:0,
                        'odds_code'=> $v['odds_code']?:'',
                        'status'=> $v['status']?:0,
                        'sort'=> $v['sort']?:0,
                        'p_code'=> $v['p_code']?:'',
                        'odds'=> $v['odds']?:0,
                        'condition'=> $v['condition'],
                        'odds_only'=> $v['odds_only']?:'',
                        'source'=> $v['source']?:'',
                        'type'=> $v['type']?:1,
                        'team'=> $v['team']?:'',
                        'lg_id'=> $lg_id,
                        'others_lg_id'=> $v['lg_id'],
                        'ctime'=> date('Y-m-d H:i:s'),
                        'utime'=> date('Y-m-d H:i:s'),
                    ];
                }

                foreach($oddsData as $k=>$v){ 
                    //获取 本地 联赛 ID
                    $lg_id = commonFunction::searcharray($v['uuid'],'identity',$l_lg_data,'lg_id');
                    //组装赔率数据
                    $set_odds[] = [
                        'match_id'=>0,
                        'others_match_id'=> $v['match_id']?:0,
                        'odds_code'=> $v['odds_code']?:'',
                        'status'=> $v['status']?:0,
                        'sort'=> $v['sort']?:0,
                        'p_code'=> $v['p_code']?:'',
                        'odds'=> $v['odds']?:0,
                        'condition'=> $v['condition'],
                        'odds_only'=> $v['odds_only']?:'',
                        'source'=> $v['source']?:'',
                        'type'=> $v['type']?:1,
                        'team'=> $v['team']?:'',
                        'lg_id'=> $lg_id,
                        'others_lg_id'=> $v['lg_id'],
                        'ctime'=> date('Y-m-d H:i:s'),
                        'utime'=> date('Y-m-d H:i:s'),
                        'sole' => $v['sole'],
                        'expire_time' => date('Y-m-d H:i:s',time()+60)
                    ];
                }

             //写赔率记录数据
             $ret = $models['model_odds_record']::insert($set_odds_r);
             if($ret != true) throw new \Exception(Response::generate($gameName.'赔率记录;',Response::ADD_ODDS_R_ERROR));
             //写赔率 数据
             $ret = $models['model_odds']::insert($set_odds);
             if($ret != true) throw new \Exception(Response::generate($gameName.'赔率;',Response::ADD_ODDS_ERROR));
    
            }
            //提交事务
            DB::commit();
            return Response::success();
        } catch (\Exception $e) {
            //回滚事务
            DB::rollBack();
            return $e->getMessage();
        }
    }

    /*
    * 写入直播 数据
    */
    public function setBroadCast(Req $data){
        //验证token
        $user = new \App\Models\System_user;
        if(empty($data->token)) return Response::generate('未获取到token',Response::TOKEN_ERR);
        $token = $user::where(['token'=>$data->token])->value('token');
        if(empty($token)) return Response::generate('token验证不通过',Response::TOKEN_ERR);
        try {
            //开启事务
            DB::beginTransaction();
            $obt = $data->data;
            //请求 数据 为空
            if(empty($obt)) throw new \Exception(Response::generate('请求数据为空，',Response::ABNORMAL));
            $getData = $this->getAddData($obt);
            //不是 直播 数据
            if($getData['title'] != 'broad_cast') throw new \Exception(Response::generate('不是直播数据，',Response::ABNORMAL));

            /*
            //写请求数据 日志记录
            $setSportsRecord = St_set_sports_recordModel::setSportsRecord($getData['title'],$obt,$getData);
            if($setSportsRecord < 1) throw new \Exception(Response::generate('',Response::SPORTS_RECORD_ERR));
            */
            //获取 球类
            $game_code = $getData['game_code'];
            //获取 直播 数据
            $BroadCast = $getData['data'];
            $set_broadcast = [];
            foreach($BroadCast as $k=>$data){
                //组装数据
                $set_broadcast[] = [
                    "doing" => $data['doing'],
                    "game_type" => $data['game_type'],
                    "game_code" => $game_code,
                    "guest_team" => $data['guest_team'],
                    "host_team" => $data['host_team'],
                    "league_name" => $data['league_name'],
                    "shower" => $data['shower'],
                    "showid" => (int)$data['showid'],
                    "start_time" => $data['start_time'],
                    "ctime" =>date('Y-m-d H:i:s'),
                    "utime" =>date('Y-m-d H:i:s'),
                ];
            }
           //写入 直播 数据
            $ret = broadcastModel::insert($set_broadcast);
            if($ret == false) throw new \Exception(Response::generate('',Response::BROADCAST_ERROR));
            //提交事务
            DB::commit();
            return Response::success();
        } catch (\Exception $e) {
            //回滚事务
            DB::rollBack();
            return $e->getMessage();
        }
    }

    /*
     * 验证所属 联赛 是否存在
     */
    public function leagueVerify($models=[],$uuid='',$source='',$gameName=''){
        if(empty($models) || empty($uuid)) throw new \Exception(Response::generate('',Response::ABNORMAL));
        $l_lg_id = $models['model_local_league']::where(['identity'=>$uuid])->value('lg_id');

        if($l_lg_id < 1) throw new \Exception(Response::generate($gameName.'联赛：lg_id-'.$uuid,Response::LEAGUE_ERROR));
        return $l_lg_id;
    }

    /*
     * 验证所属 赛事 是否存在
     */
    public function matchVerify($models=[],$s_match_id='',$source='',$gameName=''){
        if(empty($models) || empty($s_match_id)) throw new \Exception(Response::generate('',Response::ABNORMAL));
        $l_match_id = $models['model_local_match']::where(['others_match_id'=>$s_match_id,'source'=>$source])->value('match_id');

        if($l_match_id < 1) throw new \Exception(Response::generate($gameName.'赛事：match_id-'.$s_match_id,Response::MATCH_ERROR));
        return $l_match_id;
    }

    /*
     * 写入数据 接口
     */
    public function setSports(Req $data){
          try {
            //开启事务
            DB::beginTransaction();
            if($data->game_code){
                //用于后台 将所有进行中的赛事写入结果
                $this->match_result($data->game_code);
            }else{
                //验证token
                $dd = $data->session()->get('adminInfo');
                if(empty($data->token) ||($dd['token'] != $data->token))  return Response::generate('',Response::TOKEN_ERR);
        
                //写赛事数据
                $obt = $data->data;
                if($obt){
                    $getData = $this->getAddData($obt);
                    $league = [];
                    $competition = [];
                    $odds = [];
                    $odds_soly = [];
                    $league_result = [];
                    $match_result = [];
                    $match_result_record = [];
                    $odds_record = [];
                    $broadcast = [];
                    //指定排序 联赛->赛事->赔率->联赛结果->赛事结果->赛事结果记录->赔率记录->直播数据
                    foreach ($getData as $k=>$v){
                        $game_code = $v['game_code'];
                        if($v['title'] == 'league') $league[] = $v;
                        if($v['title'] == 'competition') $competition[] = $v;
                        if($v['title'] == 'odds') $odds[] = $v;
                        if($v['title'] == 'odds_sole') $odds_soly[] = $v;
                        if($v['title'] == 'league_result') $league_result[] = $v;
                        if($v['title'] == 'match_result') $match_result[] = $v;
                        if($v['title'] == 'match_result_record') $match_result_record[] = $v;
                        if($v['title'] == 'odds_record') $odds_record[] = $v;
                        if($v['title'] == 'broadcast') $broadcast[] = $v;
                    }
                    $matchData = [$league,$competition,$odds_soly,$odds,$league_result,$match_result,$match_result_record,$odds_record,$broadcast];

                    //排空处理
                    foreach ($matchData as $k=>$v){
                        if($v == []) unset($matchData[$k]);
                    }
                    sort($matchData);

                    //根据顺序写入数据
                    //降维数据
                    $mentData = [];
                    foreach ($matchData as $k=>$v){
                        foreach ($v as $kk=>$vv){
                            $mentData[] = $vv;
                        }
                    }

                    //获取各球类model
                    $models = commonFunction::getModels($game_code,1);
                    //获取球类名称
                    $gameName = gameModel::getGameName($game_code);
                    //===获取验证数据===
                    //获取一段时间内所有联赛本地记录
                    $lg_data = LeagueModel::getLeagueID($models);
                    //获取一段时间内所有赛事本地记录
                    $match_data = MatchModel::getMatchID($models);
                    //获取一段时间内所有赔率
                    $odds_data = OddsModel::getOddsID($models);
                    //获取一段时间内所有赔率记录
                    $odds_record_data = OddsRecordModel::getOddsRecordID($models);
                    //===获取验证数据===
                    $others_lg_id = '';//继承 源联赛id
                    $others_match_id = '';//继承 源赛事id
                    $s_lg_id = '';//源 联赛ID
                    $l_lg_id = '';//本地 联赛 ID
                    $s_match_id = '';//源 赛事ID
                    $l_match_id = '';//本地 赛事 ID
                    foreach ($mentData as $kk =>$vv){
                        switch ($vv['title']){
                            case 'area'://地区
                                throw new \Exception(Response::generate('地区数据-area:',Response::AUTH_ERROR)) ;
                                break;
                            case 'country'://国家
                                throw new \Exception(Response::generate('国家数据-country:',Response::AUTH_ERROR));
                                break;
                            case 'league'://联赛
                                $others_lg_id = $vv['data']['lg_id'];
                                $s_lg_id = $vv['data']['lg_id'];

                                $source = $vv['data']['source'];
                                //验证联赛记录是否已存在
                                $ret_lg = commonFunction::ver_league($s_lg_id,$source,$lg_data);
                                if($ret_lg != false) {
                                    $l_lg_id = $ret_lg;
                                    break;
                                }
                                //执行 联赛数据
                                $lg_data = $this->league($vv,$gameName);
                                $l_lg_id = $lg_data['lg_id'];
                                break;
                            case 'competition'://赛事
                                $others_match_id = $vv['data']['match_id'];
                                $s_lg_id = $vv['data']['lg_id'];
                                $s_match_id = $vv['data']['match_id'];
                                $source = $vv['data']['source'];
                                //本次请求是否包含 联赛数据
                                if(empty($others_lg_id)){
                                    //验证本地是否存在
                                    $ret_lg = commonFunction::ver_league($s_lg_id,$source,$lg_data);
                                    if($ret_lg == false) throw new \Exception(Response::generate($gameName.'联赛-lg_id:'.$s_lg_id.';',Response::LEAGUE_ERROR));
                                    $l_lg_id = $ret_lg;
                                }else{
                                    //本次有 联赛数据 验证属于同联赛
                                    if($s_lg_id != $others_lg_id) throw new \Exception(Response::generate($gameName.'联赛-lg_id:'.$s_lg_id.';',Response::LEAGUE_ERROR));
                                }
                                //验证赛事记录是否已存在
                                $ret_match = commonFunction::ver_match($s_match_id,$source,$match_data);
                                if($ret_match != false){
                                    $l_match_id = $ret_match;
                                    break;
                                }
                                //执行 赛事数据
                                $match_data = $this->competition($vv,$gameName,$l_lg_id);
                                $l_match_id = $match_data['match_id'];
                                break;
                            case 'odds'://赔率
                                $s_lg_id = $vv['data']['lg_id'];
                                $s_match_id = $vv['data']['match_id'];
                                $source = $vv['data']['source'];
                                $odds_only = $vv['data']['odds_only'];
                                $sole = $vv['data']['sole'];
                                $odds_type = $vv['data']['type'];//0普通 1冠军盘口

                                //本次请求是否包含 联赛数据
                                if(empty($others_lg_id)){
                                    //无联赛数据 验证本地是否存在
                                    $ret_lg = commonFunction::ver_league($s_lg_id,$source,$lg_data);
                                    //联赛 不存在
                                    if($ret_lg == false) throw new \Exception(Response::generate($gameName.'联赛-lg_id:'.$s_lg_id.';',Response::LEAGUE_ERROR));
                                    $l_lg_id = $ret_lg;
                                }else{
                                    //有联赛数据 验证属于同请求联赛
                                    if($s_lg_id != $others_lg_id) throw new \Exception(Response::generate($gameName.'联赛-lg_id:'.$s_lg_id.';',Response::LEAGUE_ERROR));
                                }
                                //如果是普通 赔率，则验证所属赛事
                                if($odds_type == 0){
                                    //验证赛事记录是否已存在
                                    if(empty($others_match_id)){
                                        //无赛事数据 验证本地是否存在
                                        $ret_match = commonFunction::ver_match($s_match_id,$source,$match_data);
                                        //赛事 不存在
                                        if($ret_match == false) throw new \Exception(Response::generate($gameName.'赛事-match_id:'.$s_match_id.';',Response::MATCH_ERROR));
                                        $l_match_id = $ret_match;
                                    }else{
                                        //有赛事数据 验证属于同请求赛事
                                        if($s_match_id != $others_match_id) throw new \Exception(Response::generate($gameName.'赛事-match_id:'.$s_match_id.';',Response::MATCH_ERROR));
                                    }
                                }

                                //验证赔率 是否存在
                                $ret_odds = '';
                                $ret_odds = commonFunction::ver_odds($sole,$source,$odds_data);
                                //验证赔率记录 是否存在
                                $ret_odds_record = '';
                                $ret_odds_record = commonFunction::ver_odds_record($odds_only,$source,$odds_record_data);

                                $this->odds($vv,$gameName,$l_lg_id,$l_match_id,$ret_odds,$ret_odds_record);
                                break;
                            case 'odds_sole':
                                $this->upOddsStatus($vv,$gameName);
                                break;
                            case 'league_result'://联赛结果
                                $this->league_result($vv,$gameName);
                                break;
                            case 'match_result'://赛事结果
                                throw new \Exception(Response::generate('赛事结果数据-match_result:',Response::AUTH_ERROR));
                                $this->match_result($vv,$gameName);
                                break;
                            case 'match_result_record'://赛事结果记录
                                $s_lg_id = $vv['data']['lg_id'];
                                $s_match_id = $vv['data']['match_id'];
                                $source = $vv['data']['source'];
                                //如果本次请求没有 联赛数据
                                if(empty($others_lg_id)){
                                    //验证本地是否存在
                                    $ret_lg = commonFunction::ver_league($s_lg_id,$source,$lg_data);
                                    //联赛 不存在
                                    if($ret_lg == false) throw new \Exception(Response::generate($gameName.'联赛-lg_id:'.$s_lg_id.';',Response::LEAGUE_ERROR));
                                    $l_lg_id = $ret_lg;
                                }else{
                                    //有联赛数据 验证属于同请求联赛
                                    if($s_lg_id != $others_lg_id) throw new \Exception(Response::generate($gameName.'联赛-lg_id:'.$s_lg_id.';',Response::LEAGUE_ERROR));
                                }
                                //验证赛事记录是否已存在
                                if(empty($others_match_id)){
                                    //无赛事数据 验证本地是否存在
                                    $ret_match = commonFunction::ver_match($s_match_id,$source,$match_data);
                                    //联赛 不存在
                                    if($ret_match == false) throw new \Exception(Response::generate($gameName.'赛事-match_id:'.$s_match_id.';',Response::MATCH_ERROR));
                                    $l_match_id = $ret_match;
                                }else{
                                    //有赛事数据 验证属于同请求赛事
                                    if($s_match_id != $others_match_id) throw new \Exception(Response::generate($gameName.'赛事-match_id:'.$s_match_id.';',Response::MATCH_ERROR));
                                }
                                //处理 赛事结果 记录
                                $this->com_result_record($vv,$gameName,$l_lg_id,$l_match_id);
                                break;
                            case 'broadcast'://直播数据
                                $this->broadcast($vv,$game_code);
                                break;
                            default:
                                throw new \Exception(Response::generate('',Response::ABNORMAL)) ;
                        }
                    }
                }
            }
            //提交事务
            DB::commit();
            return Response::success();
        } catch (\Exception $e) {
            //回滚事务
            DB::rollBack();
            return $e->getMessage();
        }
    }

    /**
     * @param Req $data
     * @return string
     * @throws \App\Lib\Biz\Sport\Exception
     * 更新赛事状态
     */
    public function upMatch(Req $data){
        //验证token
        $user = new \App\Models\System_user;
        if(empty($data->token)) return Response::generate('未获取到token',Response::TOKEN_ERR);
        $token = $user::where(['token'=>$data->token])->value('token');
        if(empty($token)) return Response::generate('token验证不通过',Response::TOKEN_ERR);

        try {
            //开启事务
            DB::beginTransaction();
            //获取待更新赛事
            $obt = $data->data;
            if($obt){
                //json转数组
                $data = $this->getAddData($obt);
                //获取 球类代码
                $game_code = $data['game_code'];
                //获取 数据源 
                $source = $data['source'];

                //获取所有数据源赛事 match_id
                $others_match_ids = [];
                foreach ($data['data'] as $k=>$v){
                    $others_match_ids[] = $v['match_id'];
                }
                //根据球类代码 获取model
                $model =commonFunction::getModels($game_code,1);
                //获取所有赛事 match_id
                $local_match = $model['model_local_match']::SELECT('others_match_id','match_id')
                    ->where(['source'=>$source])
                    ->whereIn('others_match_id',$others_match_ids)
                    ->get()->toArray();
                if(empty($local_match)) throw new \Exception(Response::generate('',Response::MATCHID_NULL));
                //更新状态字段
                foreach ($local_match as $k=>$v){
                    $set_status = [
                        'status'=>$v['status'],
                        'is_rollball'=>$v['is_rollball'],
                        'stais_todaytus'=>$v['is_today'],
                        'is_morningplate'=>$v['is_morningplate'],
                        'is_stringscene'=>$v['is_stringscene'],
                        'is_horn'=>$v['is_horn'],
                    ];
                    $ret = $model['model_match']::where(['id'=>$v['match_id']])
                        -> update($set_status);
                    if($ret<1) throw new \Exception(Response::generate(gameModel::getGameName($game_code).'赛事-match_id:'.$v['others_match_id'],Response::UPSTATUS_ERROR));
                }
            }
            //提交事务
            DB::commit();
            return Response::success();
        } catch (\Exception $e) {
            //回滚事务
            DB::rollBack();
            return $e->getMessage();
        }
    }

    /*
     * 写入直播 数据
     */
    public function broadcast($opt = [],$game_code=''){
        $data = $opt['data'];
        $set_broadcast = [
            "doing" => $data['doing'],
		    "game_type" => $data['game_type'],
            "game_code" => $game_code,
            "guest_team" => $data['guest_team'],
		    "host_team" => $data['host_team'],
		    "league_name" => $data['league_name'],
		    "shower" => $data['shower'],
		    "showid" => (int)$data['showid'],
            "start_time" => $data['start_time'],
            "ctime" =>date('Y-m-d H:i:s'),
            "utime" =>date('Y-m-d H:i:s'),
        ];
        $ret = broadcastModel::insert($set_broadcast);
        if($ret == false) throw new \Exception(Response::generate('',Response::BROADCAST_ERROR));
    }

    /*
     * 写入 赛事 初始 结果
     */
    public function match_result($game_code = ''){
        $model =commonFunction::getModels($game_code,1);
        if($game_code == 'zq')  ZqResultModel::ZQresult($model);
        if($game_code == 'lq')  LqResultModel::LQresult($model);
        if($game_code == 'wq')  WqResultModel::WQresult($model);
        if($game_code == 'bq')  BqResultModel::BQresult($model);
    }

    /*
     * 写入联赛数据
     */
    public function league($opt = [],$gameName=''){
        $game_code = $opt['game_code'];
        //根据球类代码获取相关model
        $model =commonFunction::getModels($game_code,1);
        $data = $opt['data'];

        //查询联赛是否已存在
        $id = $model['model_league']::where('name_chinese','=',$data['name_chinese'])
            ->value('id');
        //默认获取本年最后一天
        $last_time = date('Y-12-31 23:59:59');
        //决赛时间
        if($data['last_time']){
            $last_time = $data['last_time'];
        }
        $set_lg['name_chinese'] = $data['name_chinese'];
        $set_lg['kind'] = $data['kind'];
        $set_lg['match_mode'] = $data['match_mode'];
        $set_lg['if_stop'] = $data['if_stop'];
        $set_lg['identity'] = $data['uuid']?:'';
        $set_lg['last_time'] = $last_time;
        $set_lg['utime'] = date('Y-m-d H:i:s');
        if(empty($id)){
            //写入联赛
            $id = $model['model_league']::insertGetId($set_lg);
            $m_lg_id = $id;
            if($m_lg_id < 1) throw new \Exception(Response::generate($gameName.'联赛-lg_id:'.$data['lg_id'].';',Response::INSERT_ERROR));
        }else{
            //更新联赛
            $ret = $model['model_league']::where(['id'=>$id])
                -> update($set_lg);
            if($ret < 1) throw new \Exception(Response::generate($gameName.'联赛-lg_id:'.$data['lg_id'].';',Response::UPDATE_ERROR));
        }

        $set_local = [
            'lg_id'=>$id,
            'others_lg_id'=>$data['lg_id'],
            'source'=>$data['source'],
            'ctime'=>date('Y-m-d H:i:s')
        ];
        $ret = $model['model_local_league']::insertGetId($set_local);
        if($ret < 1) throw new \Exception(Response::generate($gameName.'联赛-lg_id:'.$data['lg_id'].';',Response::LOCAL_LEAGUE_ERROR)) ;//Render([], '10017', lang('Tips','Sports')->get('local_league_error'));

        //执行成功返回源数据 联赛ID
        $data = ['others_lg_id'=>$data['lg_id'],'lg_id'=>$id];
        return $data;
    }

    /*
     * 写入赛事数据
     */
    public function competition($opt = [],$gameName='',$lg_id=''){
        $game_code = $opt['game_code'];
        //根据球类代码获取相关model
        $model = commonFunction::getModels($game_code,1);
        $data = $opt['data'];
        if(empty($data['lg_id'])) throw new \Exception(Response::generate('',Response::LEAGUE_ERROR)) ;//Render([], '10015', lang('Tips','Sports')->get('league_error'));

        //查询赛事是否存在
        $id = $model['model_match']::where(['home_team'=>$data['home_team'],'guest_team'=>$data['guest_team'],'match_date'=>$data['match_date'],'match_time'=>$data['match_time']])
            ->value('id');

        $half_match_id = 0;
        //如果有上半场赛事id 获取上半场赛事是否存在
        if(!empty($data['half_match_id'])){
            $half_match_id = $match_id = $model['model_local_match']::where(['others_match_id'=>$data['half_match_id'],'source'=>$data['source']])
                ->value('match_id');
            if(empty($half_match_id)) throw new \Exception(Response::generate($gameName.'赛事-match_id:'.$data['match_id'].';',Response::HALF_MATCH_ERROR)) ;//Render([], '10024', lang('Tips','Sports')->get('half_match_error'));
        }
        //如果赛事没有开始日期，则为冠军盘口赛事
        if(empty($data['match_date'])){
            //冠军盘口赛事获取所属联赛结束时间
            $last_time = $model['model_league']::where(['id'=>$lg_id])
                ->value('last_time');

            if(empty($last_time)) throw new \Exception(Response::generate($gameName.'联赛-lg_id:'.$data['lg_id'].';',Response::LG_LASTTIME_ERROR)) ;//Render([], '10023', lang('Tips','Sports')->get('lg_lastTime_error'));
            //给冠军盘口赛事 赋值时间
            $time = strtotime($last_time);
            $data['match_date'] = date('Y-m-d',$time);
            $data['match_time'] = date('H:i:s',$time);
        }
        $set_match = [
            'ctime'=>date('Y-m-d H:i:s'),
            'utime'=>date('Y-m-d H:i:s'),
            'expire_time'=>date('Y-m-d H:i:s',time()+60),
            'home_team'=>$data['home_team']?:'',
            'guest_team'=>$data['guest_team']?:'no_team',
            'lg_id'=>$lg_id,
            'status'=>$data['status'],
            'match_date'=>$data['match_date']?:date('Y-m-d'),
            'match_time'=>$data['match_time']?:date('H:i:s'),
            'tag'=>$data['tag']?:0,
            'is_rollball'=>$data['is_rollball']?:0,
            'is_today'=>$data['is_today']?:0,
            'is_morningplate'=>$data['is_morningplate']?:0,
            'is_stringscene'=>$data['is_stringscene']?:0,
            'us_time'=>$data['us_time']?:commonFunction::qgmdate('Y-m-d H:i:s', '', -4),
            'half_match_id'=>$half_match_id?:0,
            'identity' => $data['uuid'],
        ];
        //写入赛事
        if(empty($id)){
            //写入赛事 返回id
            $id = $model['model_match']::insertGetId($set_match);
            if($id < 1) throw new \Exception(Response::generate($gameName.'赛事-match_id:'.$data['match_id'].';',Response::INSERT_ERROR)) ;
        }else{
            //更新赛事
            $ret = $model['model_match']::where(['id'=>$id])->update($set_match);
            if($ret < 1) throw new \Exception(Response::generate($gameName.'赛事-match_id:'.$data['match_id'].';',Response::UPDATE_ERROR)) ;
        }

        //写关联记录
        $set_local = [
            'match_id'=>$id,
            'others_match_id'=>$data['match_id'],
            'source'=>$data['source'],
            'ctime'=>date('Y-m-d H:i:s')
        ];
        $ret = $model['model_local_match']::insertGetId($set_local);
        if($ret < 1) throw new \Exception(Response::generate($gameName.'赛事-match_id:'.$data['match_id'].';',Response::LOCAL_MATCH_ERROR)) ;//Render([], '10018', lang('Tips','Sports')->get('local_match_error'));

        //返回 源数据 赛事ID
        $data = ['others_match_id'=>$data['match_id'],'match_id'=>$id];
        return $data;
    }

    /*
     * 写入赔率/赔率记录数据
     */
    public function odds($opt=[],$gameName='',$lg_id=0,$match_id=0,$oddsID='',$oddsRecordID=''){
        $game_code = $opt['game_code'];
        //根据球类代码获取相关model
        $model = commonFunction::getModels($game_code,1);
        $data = $opt['data'];

        //获取赛事 本地/源ID
        $others_match_id = $data['match_id'];

        //获取联赛 本地/源ID
        $others_lg_id = $data['lg_id'];
        //===写赔率记录===
        $set_odds_r = [
            'match_id'=> $match_id?:0,
            'others_match_id'=> $others_match_id?:0,
            'odds_code'=> $data['odds_code']?:'',
            'status'=> $data['status']?:0,
            'sort'=> $data['sort']?:0,
            'p_code'=> $data['p_code']?:'',
            'odds'=> $data['odds']?:0,
            'condition'=> $data['condition'],
            'odds_only'=> $data['odds_only']?:'',
            'source'=> $data['source']?:'',
            'type'=> $data['type']?:0,
            'team'=> $data['team']?:'',
            'lg_id'=> $lg_id,
            'others_lg_id'=> $others_lg_id,
            'ctime'=> date('Y-m-d H:i:s'),
        ];
        //更新或写入赔率记录
        if($oddsRecordID != false){
            $ret = $model['model_odds_record']::where(['id'=>$oddsRecordID])
                -> update($set_odds_r);
            if($ret < 1) throw new \Exception(Response::generate($gameName.'赔率记录-odds_only:'.$data['odds_only'].';',Response::ADD_ODDS_R_ERROR)) ;//Render([], '10020', lang('Tips','Sports')->get('add_odds_r_error'));
        }else{
            $ret = $model['model_odds_record']::insert($set_odds_r);
            if($ret != true) throw new \Exception(Response::generate($gameName.'赔率记录-odds_only:'.$data['odds_only'].';',Response::ADD_ODDS_R_ERROR));//Render([], '10020', lang('Tips','Sports')->get('add_odds_r_error'));
        }

        //===写赔率===
        $set_odds = [
            'match_id'=> $match_id?:0,
            'others_match_id'=> $others_match_id?:0,
            'odds_code'=> $data['odds_code']?:'',
            'status'=> $data['status']?:0,
            'sort'=> $data['sort']?:0,
            'p_code'=> $data['p_code']?:'',
            'odds'=> $data['odds']?:0,
            'condition'=> $data['condition'],
            'odds_only'=> $data['odds_only']?:'',
            'sole'=> $data['sole']?:'',
            'source'=> $data['source']?:'',
            'type'=> $data['type']?:0,
            'team'=> $data['team']?:'',
            'lg_id'=> $lg_id,
            'others_lg_id'=> $others_lg_id,
            'ctime'=> date('Y-m-d H:i:s'),
            'utime'=> date('Y-m-d H:i:s'),
            'expire_time'=>date('Y-m-d H:i:s',time()+60),
        ];
        //更新或写入赔率数据
        if($oddsID != false){
            $ret = $model['model_odds']::where(['id'=>$oddsID])
                -> update($set_odds);
            if($ret < 1) throw new \Exception(Response::generate($gameName.'赔率-odds_only:'.$data['odds_only'].';',Response::ADD_ODDS_ERROR));//Render([], '10019', lang('Tips','Sports')->get('add_odds_error'));
        }else{
            $ret = $model['model_odds']::insert($set_odds);
            if($ret != true) throw new \Exception(Response::generate($gameName.'赔率-odds_only:'.$data['odds_only'].';',Response::ADD_ODDS_ERROR));//Render([], '10019', lang('Tips','Sports')->get('add_odds_error'));
        }
        //===end===
    }

    /*
     * 更新 赛事下 所有不在本次请求的 赔率状态
     */
    public function upOddsStatus($opt = [],$gameName=''){
        //获取球类代码
        $game_code = $opt['game_code'];
        //获取球类model
        $model = commonFunction::getModels($game_code,1);
        //赛事下 所有 赔率sole
        $odds_sole = $opt['data'];
        //数据源 赛事 id
        $others_match_id = $opt['match_id'];
        //数据源
        $source = $opt['source'];
        //更新赛事下所有 不在本次请求的赔率 状态
        $ret= OddsModel::upOddsStatus($model,$others_match_id,'',$source,$odds_sole);
        if($ret != true) throw new \Exception(Response::generate($gameName,Response::ODDS_SOLE_ERR));
    }

    /*
     * 写入联赛结果
     */
    public function league_result($opt,$gameName){
        $game_code = $opt['game_code'];
        //根据球类代码获取相关model
        $model = commonFunction::getModels($game_code,1);
        $data = $opt['data'];

        //验证结果所属联赛
        $lg_id = $model['model_local_league']::where(['others_lg_id'=>$data['lg_id'],'source'=>$data['source']])
            ->value('lg_id');
        if($lg_id < 1) throw new \Exception(Response::generate($gameName.'联赛-lg_id:'.$data['lg_id'].';',Response::LEAGUE_ERROR));

        $lg_result_id = $model['model_league_result']::where(['lg_id'=>$lg_id,'game_name'=>$data['game_name']])
            ->value('id');
        $set_lg_result = [
            'lg_id'=>$lg_id,
            'game_name'=>$data['game_name'],
            'result'=>json_encode($data['result'],JSON_UNESCAPED_UNICODE),
            'status'=>$data['status'],
            'ctime'=> date('Y-m-d H:i:s'),
            'utime'=> date('Y-m-d H:i:s'),
        ];
        //联赛结果数据处理
        if(!empty($lg_result_id)){
            $ret = $model['model_league_result']::where(['id'=>$lg_result_id])
                -> update($set_lg_result);
            if($ret < 1) throw new \Exception(Response::generate($gameName.'联赛-lg_id:'.$data['lg_id'].';',Response::ADD_LG_R_ERROR)) ;//Render([], '10021', lang('Tips','Sports')->get('add_lg_r_error'));
        }else{
            $ret = $model['model_league_result']::insert($set_lg_result);
            if($ret != true) throw new \Exception(Response::generate($gameName.'联赛-lg_id:'.$data['lg_id'].';',Response::ADD_LG_R_ERROR));//Render([], '10021', lang('Tips','Sports')->get('add_lg_r_error'));
        }
    }

    /*
     * 写入赛事结果
     */
    public function com_result($opt=[],$gameName='',$lg_id='',$match_id=''){
        $game_code = $opt['game_code'];
        //根据球类代码获取相关model
        $model = commonFunction::getModels($game_code,1);
        $data = $opt['data'];
        //查询结果是否存在
        $match_r_id = $model['model_result']::where(['match_id'=>$match_id])
            ->value('id');

        $set_match_r = [
            "home_team"=>$data['home_team'],
            "guest_team"=>$data['guest_team'],
            "lg_id"=>$lg_id,
            "home_rate"=> $data['home_rate'],
            "guest_rate"=> $data['guest_rate'],
            "home_score"=> $data['home_score'],
            "guest_score"=> $data['guest_score'],
            "all_goal"=> $data['all_goal'],
            "status"=>$data['status'],
            "first_score"=>$data['first_score'],
            "last_score"=> $data['last_score'],
            "match_score"=> $data['match_score'],
            "match_winer"=> $data['match_winer'],
            "match_time"=> $data['match_time'],
            "match_process"=> $data['match_process'],
            "tag"=> $data['tag'],
            "match_id"=> $match_id,
            "u_home_score"=> $data['u_home_score'],
            "u_guest_score"=> $data['u_guest_score'],
            "p_code"=> $data['p_code'],
            "update_time"=>date('Y-m-d H:i:s')
        ];
        //赛事结果数据处理
        if(!empty($match_r_id)){
            $ret = $model['model_result']::where(['id'=>$match_r_id])
                -> update($set_match_r);
            if($ret < 1) throw new \Exception(Response::generate($gameName.'赛事-match_id:'.$data['match_id'].';',Response::ADD_MATCH_R_ERROR)) ;//Render([], '10022', lang('Tips','Sports')->get('add_match_r_error'));
        }else{
            $ret = $model['model_result']::insert($set_match_r);
            if($ret != true) throw new \Exception(Response::generate($gameName.'赛事-match_id:'.$data['match_id'].';',Response::ADD_MATCH_R_ERROR)) ;//Render([], '10022', lang('Tips','Sports')->get('add_match_r_error'));
        }
//        return Response::success();
    }

    //写入赛事结果记录
    public function com_result_record($opt=[],$gameName='',$lg_id='',$match_id=''){
        $game_code = $opt['game_code'];
        //根据球类代码获取相关model
        $model = commonFunction::getModels($game_code,1);
        $data = $opt['data'];

        $match_r_id = $model['model_result_record']::where(['match_id'=>$match_id,'match_time'=>$data['match_time']])
            ->value('id');
        //根据球类 获取 赛事结果记录字段
        $set_match_r = $this->get_match_r($game_code,$lg_id,$match_id,$data);

        //赛事结果记录处理
        if($match_r_id > 0){
            $ret = $model['model_result_record']::where(['id'=>$match_r_id])
                ->update($set_match_r);
            if($ret < 1) throw new \Exception(Response::generate($gameName.'赛事-match_id:'.$data['match_id'].';',Response::ADD_MATCH_R_R_ERROR));//Render([], '10022', lang('Tips','Sports')->get('add_match_r_r_error'));
        }else{
            $ret = $model['model_result_record']::insert($set_match_r);
            if($ret != true) throw new \Exception(Response::generate($gameName.'赛事-match_id:'.$data['match_id'].';',Response::ADD_MATCH_R_R_ERROR));//Render([], '10022', lang('Tips','Sports')->get('add_match_r_r_error'));
        }
    }

    /**
     * @param $data
     * @return mixed
     * json转数组
     */
    public function getAddData($data){

        $data = json_decode($data,true);

        return $data;
    }

    /*
     * 根据球类获取 赛事结果记录字段
     */
    public function get_match_r($game_code,$lg_id,$match_id,$data){
        $set_match_r = [];
        if($game_code == 'zq'){
            $set_match_r = [
                "home_team"=>$data['home_team']?:'',
                "guest_team"=>$data['guest_team']?:'',
                "lg_id"=>$lg_id,
                "all_goal"=>$data['all_goal']?:0,
                "home_rate"=> $data['home_rate']?:0,
                "guest_rate"=> $data['guest_rate']?:0,
                "home_score"=> $data['home_score']?:0,
                "guest_score"=> $data['guest_score']?:0,
                "status"=>$data['status']?:0,
                "first_score"=>$data['first_score']?:0,
                "last_score"=> $data['last_score']?:0,
                "match_score"=> $data['match_score']?:0,
                "match_winer"=> $data['match_winer']?:'',
                "match_time"=> $data['match_time']?:0,
                "match_process"=> $data['match_process']?:'',
                // "tag"=> $data['tag']?:0,
                "match_id"=> $match_id,
                "update_time"=>date('Y-m-d H:i:s')
            ];
        };
        if($game_code == 'lq'){
            $set_match_r = [
                "home_team"=>$data['home_team']?:'',
                "guest_team"=>$data['guest_team']?:'',
                "lg_id"=>$lg_id,
                "home_rate"=> $data['home_rate']?:0,
                "guest_rate"=> $data['guest_rate']?:0,
                "home_score"=> $data['home_score']?:0,
                "guest_score"=> $data['guest_score']?:0,
                "status"=>$data['status']?:0,
                "first_score"=>$data['first_score']?:0,
                "last_score"=> $data['last_score']?:0,
                "match_score"=> $data['match_score']?:0,
                "match_winer"=> $data['match_winer']?:'',
                "match_time"=> $data['match_time']?:0,
                "match_process"=> $data['match_process']?:'',
                // "tag"=> $data['tag']?:0,
                "match_id"=> $match_id,
                "update_time"=>date('Y-m-d H:i:s')
            ];
        }
        if($game_code == 'wq'){
            $set_match_r = [
                "home_player_name"=>$data['home_player_name']?:'',
                "guest_player_name"=>$data['guest_player_name']?:'',
                "lg_id"=>$lg_id,
                "home_player_let_plate"=>$data['home_player_let_plate']?:0,
                "guest_player_let_plate"=>$data['guest_player_let_plate']?:0,
                "home_player_let_inning"=>$data['home_player_let_inning']?:0,
                "guest_player_let_inning"=>$data['guest_player_let_inning']?:0,
                "all_inning"=>$data['all_inning']?:0,
                "home_player_score"=>$data['home_player_score']?:0,
                "guest_player_score"=>$data['guest_player_score']?:0,
                "status"=>$data['status']?:0,
                "first_score_player"=>$data['first_score_player']?:'',
                "last_score_player"=>$data['last_score_player']?:'',
                "first_inning_score"=>$data['first_inning_score']?:0,
                "second_inning_score"=>$data['second_inning_score']?:0,
                "third_inning_score"=>$data['third_inning_score']?:0,
                "match_winer_player"=>$data['match_winer_player']?:'',
                "update_time"=>date('Y-m-d H:i:s'),
                "match_time"=>$data['match_time']?:0,
                "match_process"=>$data['match_process']?:'',
                // "tag"=>$data['tag']?:0,
                "match_id"=>$match_id,
                "result_mark" =>$data['result_mark']?:'',
            ];
        }
        if($game_code == 'bq'){
            $set_match_r = [
                "home_team"=>$data['home_team']?:'',
                "guest_team"=>$data['guest_team']?:'',
                "lg_id"=>$lg_id,
                "home_rate"=> $data['home_rate']?:0,
                "guest_rate"=> $data['guest_rate']?:0,
                "home_score"=> $data['home_score']?:0,
                "guest_score"=> $data['guest_score']?:0,
                "status"=>$data['status']?:0,
                "first_score"=>$data['first_score']?:0,
                "last_score"=> $data['last_score']?:0,
                "match_score"=> $data['match_score']?:0,
                "match_winer"=> $data['match_winer']?:'',
                "match_time"=> $data['match_time']?:0,
                "match_process"=> $data['match_process']?:'',
                // "tag"=> $data['tag']?:0,
                "match_id"=> $match_id,
                "all_inning"=>$data['all_inning']?:9,
                "update_time"=>date('Y-m-d H:i:s'),
                "result_mark" =>$data['result_mark']?:'',
            ];
        }

        return $set_match_r;
    }
}