897 lines
31 KiB
PHP
Executable File
897 lines
31 KiB
PHP
Executable File
<?php
|
|
|
|
namespace App\Service;
|
|
|
|
use App\Enums\BoolEnum;
|
|
use App\Enums\LottType;
|
|
use App\Enums\OrderType;
|
|
use App\Enums\PayState;
|
|
use App\Enums\PlayType;
|
|
use App\Exceptions\JingCaiException;
|
|
use App\Model\Config;
|
|
use App\Model\Customer\Customer;
|
|
use App\Model\Lottery;
|
|
use App\Model\LotteryType;
|
|
use App\Model\Order;
|
|
use App\Model\OrderBjdcSfggResult;
|
|
use App\Model\OrderBjdcSfggZuhe;
|
|
use App\Model\Seller\Seller;
|
|
use App\Model\Zq\BjdcResult;
|
|
use App\Model\Zq\BjdcSfggOdds;
|
|
use App\Model\Zq\BjdcSfggResult;
|
|
use App\Utils\Helps;
|
|
use App\Utils\ThrowException;
|
|
use Illuminate\Support\Arr;
|
|
use Illuminate\Support\Facades\DB;
|
|
use Illuminate\Support\Facades\Log;
|
|
|
|
class BjdcSfggService implements IJingcai
|
|
{
|
|
use JingCaiTrait;
|
|
|
|
/** @var PlayTypeService playTypeService */
|
|
protected $playTypeService;
|
|
|
|
public function __construct()
|
|
{
|
|
$this->playTypeService = app(PlayTypeService::class);
|
|
}
|
|
|
|
public function playTypeNames()
|
|
{
|
|
return [
|
|
'sfgg_odds' => '胜负过关',
|
|
|
|
];
|
|
}
|
|
|
|
public function getPlayTypeName($playType)
|
|
{
|
|
$fieldNames = $this->playTypeNames();
|
|
$result = $fieldNames[$playType];
|
|
return $result;
|
|
}
|
|
|
|
public function resultFieldNames()
|
|
{
|
|
return [
|
|
'win' => '胜',
|
|
'draw' => '平',
|
|
'loss' => '负',
|
|
'handicap' => '让球数',
|
|
|
|
];
|
|
}
|
|
|
|
public function getResultFieldName($playType, $field)
|
|
{
|
|
$fieldNames = $this->resultFieldNames();
|
|
$result = $fieldNames[$field];
|
|
if (!in_array($field, ['win', 'loss', 'draw']) || $playType != 'rq_odds') {
|
|
return $result;
|
|
}
|
|
return '让' . $result;
|
|
}
|
|
|
|
public static function generateZqPassModeInfo($oddsData, $playType)
|
|
{
|
|
$matchNum = count($oddsData);
|
|
if ($matchNum > 15) {
|
|
$matchNum = 15;
|
|
}
|
|
$multi = [];
|
|
for ($i = 3; $i <= $matchNum; $i++) {
|
|
$title = $i . '串1';
|
|
$multi[] = [
|
|
'key' => $i . '.1',
|
|
'title' => $title,
|
|
];
|
|
}
|
|
return [
|
|
'multi' => $multi,
|
|
'single' => []
|
|
];
|
|
}
|
|
|
|
public function saleLotteries(Customer $customer, $lotteryTypeId)
|
|
{
|
|
$lotteryType = LotteryType::where('type', LottType::BJDC_SFGG)
|
|
->where('status', BoolEnum::YES)
|
|
->find($lotteryTypeId);
|
|
ThrowException::isTrue(!$lotteryType, '不支持此彩种!');
|
|
|
|
$lottery = Lottery::active()
|
|
->shopAndType($customer->shop_id, $lotteryTypeId)
|
|
->first();
|
|
ThrowException::isTrue(!$lotteryType, '店铺不支持此彩种');
|
|
|
|
$odds = BjdcSfggOdds::selling()
|
|
->where('close_time', '>', date('Y-m-d H:i:s', time() + $lottery->earlySecond()))
|
|
->orderBy('play_num', 'asc')
|
|
->orderBy('issue_num', 'asc')
|
|
->get();
|
|
|
|
$result = [
|
|
'play_types' => PlayType::asBjdcSfggSelectArray(),
|
|
];
|
|
|
|
$competitions = [];
|
|
/** @var BjdcSfggOdds $odd */
|
|
foreach ($odds as $odd) {
|
|
|
|
if (!in_array($odd->bd_competition_name, $competitions)) {
|
|
$competitions[] = $odd->bd_competition_name;
|
|
}
|
|
$odd->bd_competition_name = preg_replace('/[0-9]/', '', $odd->bd_competition_name);
|
|
$realCloseTime = strtotime($odd->close_time) - $lottery->earlySecond();
|
|
$odd->close_time = date('Y-m-d H:i:s', $realCloseTime);
|
|
$odd->real_close_str = date('H:i', $realCloseTime) . '截止';
|
|
$odd->sfgg_odds = Helps::compareOdds($odd->sfgg_odds, $odd->sfgg_odds_last);
|
|
|
|
|
|
BjdcSfggOdds::unsetLastSuffixField($odd);
|
|
}
|
|
if ($competitions) {
|
|
array_unshift($competitions, '全部');
|
|
}
|
|
|
|
$result['competitions'] = $competitions;
|
|
$result['odds'] = $odds;
|
|
return $result;
|
|
}
|
|
|
|
|
|
public function refreshOddsWithResult($oddsData)
|
|
{
|
|
$ids = array_keys($oddsData);
|
|
if (!$ids) {
|
|
return $oddsData;
|
|
}
|
|
$results = BjdcSfggResult::whereIn('bjdc_sfgg_odds_id', $ids)
|
|
->get()
|
|
->keyBy('bjdc_sfgg_odds_id');
|
|
|
|
foreach ($oddsData as $id => &$oddItem) {
|
|
/** @var BjdcSfggResult $result */
|
|
$result = Arr::get($results, $id);
|
|
if (!$result) {
|
|
continue;
|
|
}
|
|
$cancel = $result->canceled();
|
|
foreach ($oddItem as $playType => &$playData) {
|
|
foreach ($playData as $playName => &$playOdds) {
|
|
if ($cancel) {
|
|
$playOdds = 1;
|
|
continue;
|
|
}
|
|
$resultPlayName = str_replace('_odds', '_field', $playType);
|
|
|
|
if ($playName == $result->{$resultPlayName}) {
|
|
$playOdds = Helps::floatFormat($result->{$playType});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return $oddsData;
|
|
}
|
|
public function refreshOdds($data)
|
|
{
|
|
$ids = array_keys($data);
|
|
throw_if(!$ids, JingCaiException::create('请选择比赛进行投注'));
|
|
|
|
$odds = BjdcSfggOdds::whereIn('id', $ids)->get();
|
|
$odds = collect($odds);
|
|
ThrowException::isTrue($odds->count() != count($ids), '比赛数据错误，请重新选择');
|
|
|
|
$result = [];
|
|
foreach ($data as $id => $val) {
|
|
$item = [];
|
|
foreach ($val as $playType => $playData) {
|
|
$oddItem = $odds->where('id', $id)->first();
|
|
foreach ($playData as $k => $v) {
|
|
$odd = Arr::get($oddItem, $playType . '.' . $k);
|
|
if (!$odd) {
|
|
Log::error('JczqService->refreshOdds数据错误', [
|
|
'data' => $data,
|
|
'key' => $playType . '.' . $k,
|
|
'val' => $odd,
|
|
'id' => $id,
|
|
]);
|
|
}
|
|
|
|
throw_if($odd === null, JingCaiException::create('数据错误，请重新选择'));
|
|
|
|
$item[$playType][$k] = Arr::get($oddItem, $playType . '.' . $k);
|
|
}
|
|
}
|
|
$result[$id] = $item;
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
public function computePrizeInfo($data, $betsNum = 1, $passModeKeys = [])
|
|
{
|
|
sort($passModeKeys);
|
|
$zhuTotal = 0;
|
|
$min = 0;
|
|
$max = 0;
|
|
foreach ($passModeKeys as $key) {
|
|
|
|
$keyArr = explode('.', $key);
|
|
$change = $keyArr[0];
|
|
|
|
$prizeInfo = $this->generatePrizeOdds($data, $change);
|
|
$zhuTotal += $prizeInfo['zhu_num'];
|
|
if (!$min) {
|
|
$min = $prizeInfo['min'];
|
|
}
|
|
if ($prizeInfo['min'] < $min) {
|
|
$min = $prizeInfo['min'];
|
|
}
|
|
$max += $prizeInfo['max'];
|
|
}
|
|
return [
|
|
'zhu_num' => $zhuTotal,
|
|
'expect_bets' => 0,
|
|
'money' => Helps::floatFormat($zhuTotal * $betsNum * Config::lotteryUnitPrice()),
|
|
'prize_min' => Helps::floatFormat($min * $betsNum * Config::lotteryUnitPrice() * Config::bjdcPrizePercent()),
|
|
'prize_max' => Helps::floatFormat($max * $betsNum * Config::lotteryUnitPrice() * Config::bjdcPrizePercent())
|
|
];
|
|
}
|
|
|
|
public function generatePrizeOdds($data, $len)
|
|
{
|
|
$errRes = [
|
|
'zhu_num' => 0,
|
|
'min' => 0,
|
|
'max' => 0,
|
|
];
|
|
$fdata = $this->generateCombinationInput($data);
|
|
if (!$fdata) {
|
|
Log::error('generatePrize格式化数据失败', [
|
|
'data' => $data,
|
|
'len' => $len
|
|
]);
|
|
return $errRes;
|
|
}
|
|
$combinationData = Helps::getCombinationData($fdata, $len);
|
|
if (!$combinationData) {
|
|
Log::error('generatePrize生成组合数据失败', [
|
|
'fdata' => $fdata,
|
|
'len' => $len
|
|
]);
|
|
return $errRes;
|
|
}
|
|
|
|
$prizes = [];
|
|
$zhuTotal = count($combinationData);
|
|
foreach ($combinationData as $keyArr) {
|
|
$keyOdds = 1;
|
|
foreach ($keyArr as $key) {
|
|
$keyInfo = $this->parseJczqCombinationItem($key);
|
|
$baseItemArr = Arr::get($data, $keyInfo['id']);
|
|
$odds = Arr::get($baseItemArr, $keyInfo['play'] . '.' . $keyInfo['result'], null);
|
|
$keyOdds *= $odds;
|
|
}
|
|
$prizes[] = $keyOdds;
|
|
|
|
}
|
|
sort($prizes, SORT_ASC);
|
|
return [
|
|
'zhu_num' => $zhuTotal,
|
|
'min' => $prizes[0],
|
|
'max' => $prizes[count($prizes) - 1],
|
|
];
|
|
}
|
|
|
|
public function generateJczqCombinationItem($id, $playType, $result)
|
|
{
|
|
return sprintf('%d-%s-%s', $id, $playType, $result);
|
|
}
|
|
|
|
public function parseJczqCombinationItem($key)
|
|
{
|
|
$info = explode('-', $key);
|
|
return [
|
|
'id' => $info[0],
|
|
'play' => $info[1],
|
|
'result' => $info[2],
|
|
];
|
|
}
|
|
|
|
public function generateCombinationInput($data, $hasOdds = false)
|
|
{
|
|
$result = [];
|
|
foreach ($data as $id => $item) {
|
|
$resItem = [];
|
|
foreach ($item as $k => $itemData) {
|
|
foreach ($itemData as $kk => $kkv) {
|
|
$resKey = $this->generateJczqCombinationItem($id, $k, $kk);
|
|
if ($hasOdds) {
|
|
$resItem[$resKey] = $kkv;
|
|
} else {
|
|
$resItem[$resKey] = $resKey;
|
|
}
|
|
}
|
|
}
|
|
$result[] = $resItem;
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
public function getBetsInfoFromCombinationData($data, $betsNum = 1, $dataOdd)
|
|
{
|
|
$result = [];
|
|
foreach ($data as $zuheInfo) {
|
|
$resultItem = [];
|
|
$allOdds = 1;
|
|
foreach ($zuheInfo as $key) {
|
|
$keyInfo = $this->parseJczqCombinationItem($key);
|
|
$keyInfo['odd'] = $this->getBetsOddFromCombinationData($key, $dataOdd);
|
|
$allOdds *= $keyInfo['odd'];
|
|
|
|
$resultItem['ids'][] = intval($keyInfo['id']);
|
|
$resultItem['keys'][] = $key;
|
|
$resultItem['info'][$keyInfo['id']] = $keyInfo;
|
|
$resultItem['bets_num'] = $betsNum;
|
|
}
|
|
$tempKeys = $resultItem['keys'];
|
|
sort($tempKeys);
|
|
$resultItem['unique'] = implode(';', $tempKeys);
|
|
$resultItem['all_odds'] = $allOdds;
|
|
|
|
$result[] = $resultItem;
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
public function piaoMatchCanAddPlay($piao, $betsInfo)
|
|
{
|
|
foreach ($piao['bets'] as $item) {
|
|
$intersectIds = array_intersect($item['ids'], $betsInfo['ids']);
|
|
if ($intersectIds) {
|
|
|
|
foreach ($intersectIds as $id) {
|
|
if ($item['info'][$id]['play'] != $betsInfo['info'][$id]['play']) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public function piaoAddBets(&$piaos, $betsInfo)
|
|
{
|
|
$addPiao = false;
|
|
if (!$piaos) {
|
|
$piaos = [];
|
|
$betsNumAll = $betsInfo['bets_num'];
|
|
// 超出限制，添加一部分，返回剩余的
|
|
if ($betsNumAll > Config::piaoMaxBetsNum()) {
|
|
$addNum = Config::piaoMaxBetsNum();
|
|
|
|
$tempBetsInfo = $betsInfo;
|
|
$betsInfo['bets_num'] = $addNum;
|
|
$piaos[0]['bets'][] = $betsInfo;
|
|
$piaos[0]['bets_num'] = $addNum;
|
|
$tempBetsInfo['bets_num'] -= $addNum;
|
|
return $this->piaoAddBets($piaos, $tempBetsInfo);
|
|
}
|
|
|
|
$piaos[0] = [
|
|
'bets' => [$betsInfo],
|
|
'bets_num' => $betsInfo['bets_num']
|
|
];
|
|
$addPiao = true;
|
|
return $addPiao;
|
|
}
|
|
foreach ($piaos as $pk => $piao) {
|
|
|
|
if ($piaos[$pk]['bets_num'] >= Config::piaoMaxBetsNum()) {
|
|
continue;
|
|
}
|
|
|
|
// 同一场只能出现一个玩法
|
|
$can = $this->piaoMatchCanAddPlay($piao, $betsInfo);
|
|
if (!$can) {
|
|
continue;
|
|
}
|
|
|
|
$betsNumAll = $piaos[$pk]['bets_num'] + $betsInfo['bets_num'];
|
|
|
|
// 超出限制，添加一部分，返回剩余的
|
|
if ($betsNumAll > Config::piaoMaxBetsNum()) {
|
|
$addNum = Config::piaoMaxBetsNum() - $piaos[$pk]['bets_num'];
|
|
|
|
$tempBetsInfo = $betsInfo;
|
|
$betsInfo['bets_num'] = $addNum;
|
|
$piaos[$pk]['bets'][] = $betsInfo;
|
|
$piaos[$pk]['bets_num'] += $addNum;
|
|
$tempBetsInfo['bets_num'] -= $addNum;
|
|
return $this->piaoAddBets($piaos, $tempBetsInfo);
|
|
}
|
|
|
|
$addPiao = true;
|
|
$piaos[$pk]['bets'][] = $betsInfo;
|
|
$piaos[$pk]['bets_num'] += $betsInfo['bets_num'];
|
|
}
|
|
|
|
if (!$addPiao) {
|
|
$nextPk = count($piaos);
|
|
|
|
$betsNumAll = $betsInfo['bets_num'];
|
|
// 超出限制，添加一部分，返回剩余的
|
|
if ($betsNumAll > Config::piaoMaxBetsNum()) {
|
|
$addNum = Config::piaoMaxBetsNum();
|
|
$tempBetsInfo = $betsInfo;
|
|
|
|
$betsInfo['bets_num'] = $addNum;
|
|
|
|
$piaos[$nextPk]['bets'][] = $betsInfo;
|
|
$piaos[$nextPk]['bets_num'] = $addNum;
|
|
|
|
$tempBetsInfo['bets_num'] -= $addNum;
|
|
return $this->piaoAddBets($piaos, $tempBetsInfo);
|
|
}
|
|
|
|
$piaos[$nextPk] = [
|
|
'bets' => [$betsInfo],
|
|
'bets_num' => $betsInfo['bets_num']
|
|
];
|
|
}
|
|
}
|
|
|
|
public function createPiaos($betsInfos)
|
|
{
|
|
$piaos = [];
|
|
foreach ($betsInfos as $betsInfo) {
|
|
$this->piaoAddBets($piaos, $betsInfo);
|
|
}
|
|
return $piaos;
|
|
}
|
|
|
|
public function valid(Lottery $lottery, $playType, $data)
|
|
{
|
|
ThrowException::isTrue(count($data) < 3, '至少选择3场比赛');
|
|
|
|
}
|
|
|
|
/**
|
|
* 根据用户的下注数据，生成购物车中的比赛下注信息
|
|
* @param Array $matchs
|
|
* @return array
|
|
*/
|
|
public function getBjdcSfggOddsFromData(Lottery $lottery, $oddsData)
|
|
{
|
|
$jczqCount = BjdcSfggOdds::selling()->whereIn('id', array_keys($oddsData))->count();
|
|
throw_if($jczqCount != count($oddsData), JingCaiException::create('比赛信息有误'));
|
|
$odds = BjdcSfggOdds::selling()
|
|
->whereIn('id', array_keys($oddsData))
|
|
->get();
|
|
|
|
$result = [];
|
|
foreach ($odds as $odd) {
|
|
|
|
$odd->bd_competition_name = preg_replace('/[0-9]/', '', $odd->bd_competition_name);
|
|
|
|
$realCloseTime = strtotime($odd->real_close_time) - $lottery->earlySecond();
|
|
$odd->real_close_time = date('Y-m-d H:i:s', $realCloseTime);
|
|
$odd->real_close_str = date('H:i', $realCloseTime) . '截止';
|
|
|
|
unset($odd->sfgg_odds_last);
|
|
if (@$oddsData[$odd->id]['sfgg_odds']) {
|
|
$odd->sfgg_odds = Helps::copyProperty($odd->sfgg_odds, $oddsData[$odd->id]['sfgg_odds']);
|
|
} else {
|
|
Log::error('getBjdcSfggOddsFromData的数据没有sfgg_odds', $odd->toArray());
|
|
ThrowException::run('数据有误，请联系管理员');
|
|
}
|
|
$result[] = $odd;
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
public function generateBetsInfo($odds, $passModeKeys, $betsNum)
|
|
{
|
|
$data = $this->generateCombinationInput($odds);
|
|
$result = [];
|
|
foreach ($passModeKeys as $key) {
|
|
$passModes = self::getPassMode($key);
|
|
foreach ($passModes as $chang => $changeGe) {
|
|
$combinationData = Helps::getCombinationData($data, $chang);
|
|
$result = array_merge($result, $combinationData);
|
|
}
|
|
}
|
|
$dataOdd = $this->generateCombinationInput($odds, true);
|
|
return $this->getBetsInfoFromCombinationData($result, $betsNum, $dataOdd);
|
|
}
|
|
|
|
public function createOrder(Customer $customer, $data)
|
|
{
|
|
$lotteryTypeId = Arr::get($data, 'lottery_type_id');
|
|
$playType = Arr::get($data, 'play_type', '');
|
|
$type = Arr::get($data, 'type', OrderType::NORMAL);
|
|
$fadanSecret = Arr::get($data, 'type_mode', 1);
|
|
$fadanDesc = Arr::get($data, 'type_desc', '');
|
|
$betsNum = Arr::get($data, 'bets_num');
|
|
$passModeKeys = Arr::get($data, 'pass_mode_keys');
|
|
$odds = Arr::get($data, 'odds'); // 购买的场次或投注信息
|
|
$union_piece_total = intval(Arr::get($data, 'union_piece_total', 0));
|
|
$union_piece_buy = intval(Arr::get($data, 'union_piece_buy', 0));
|
|
$union_piece_keep = intval(Arr::get($data, 'union_piece_keep', 0));
|
|
$union_keep = Arr::get($data, 'union_keep', BoolEnum::NO);
|
|
$union_brokerage = intval(Arr::get($data, 'union_brokerage', 0));
|
|
$fadan_order_no = Arr::get($data, 'fadan_order_no', '');
|
|
|
|
|
|
ThrowException::isTrue(!$passModeKeys, '请选择串关');
|
|
|
|
ThrowException::isTrue($type == OrderType::FADAN, '不支持发单');
|
|
ThrowException::isTrue($type == OrderType::GENDAN, '不支持跟单');
|
|
|
|
/** @var Lottery $lott */
|
|
$lott = LotteryService::getLottery($customer->shop->id, $lotteryTypeId);
|
|
throw_if(!$lott, JingCaiException::create('店铺未开通该彩种!'));
|
|
|
|
$this->valid($lott, $playType, $odds);
|
|
|
|
$odds = $this->refreshOdds($odds);
|
|
|
|
$computeInfo = $this->computePrizeInfo($odds, $betsNum, $passModeKeys);
|
|
|
|
$lott->validMixMoney($computeInfo['money']);
|
|
|
|
|
|
if ($type == OrderType::FADAN) {
|
|
throw_if(!$fadanDesc, JingCaiException::create('请填写发单宣言!'));
|
|
$this->canCreateFanDanOrder($customer->id);
|
|
|
|
ThrowException::isTrue($this->fadanValid($computeInfo['money'], $computeInfo['prize_min']), '最低奖金大于等于投注金额的1.6倍');
|
|
}
|
|
if ($type == OrderType::UNION) {
|
|
$lott->validEnableHemai();
|
|
throw_if(!$fadanDesc, JingCaiException::create('请填写合买宣言!'));
|
|
ThrowException::isTrue($union_piece_total <= 0, '总份数不能小于0');
|
|
$piecePrice = $computeInfo['money'] / $union_piece_total;
|
|
ThrowException::isTrue($piecePrice <= 1, '每份金额必须大于1');
|
|
|
|
ThrowException::isTrue($union_piece_buy > $union_piece_total, '超过方案总金额');
|
|
if ($union_keep == BoolEnum::YES) {
|
|
$union_piece_keep = $union_piece_total - $union_piece_buy;
|
|
}
|
|
|
|
$this->canCreateUnionOrder($customer->id);
|
|
}
|
|
|
|
$pid = 0;
|
|
|
|
DB::beginTransaction();
|
|
try {
|
|
|
|
$bjdcOdds = BjdcSfggOdds::whereIn('id', array_keys($odds))->get();
|
|
$closeTimes = [];
|
|
$oddsCloseTimes = [];
|
|
$issueNum = '';
|
|
foreach ($bjdcOdds as $match) {
|
|
$realCloseTime = strtotime($match->close_time) - $lott->earlySecond();
|
|
$real_close_time = date('Y-m-d H:i:s', $realCloseTime);
|
|
$closeTimes[] = $real_close_time;
|
|
$oddsCloseTimes[] = date('Y-m-d H:i:s', strtotime($match->close_time));
|
|
if ($issueNum && $issueNum != $match->issue_num) {
|
|
ThrowException::run('无法跨期投注');
|
|
}
|
|
$issueNum = $match->issue_num;
|
|
}
|
|
sort($closeTimes);
|
|
sort($oddsCloseTimes);
|
|
$earlyTime = $closeTimes[0];
|
|
$oddsCloseTime = $oddsCloseTimes[0];
|
|
$lateTime = $closeTimes[count($closeTimes) - 1];
|
|
|
|
$this->checkCloseTimeOver($earlyTime);
|
|
|
|
$betsInfos = $this->generateBetsInfo($odds, $passModeKeys, $betsNum);
|
|
$piaos = $this->createPiaos($betsInfos);
|
|
|
|
$order = new Order();
|
|
$order->pid = $pid;
|
|
$order->customer_id = $customer->id;
|
|
$order->lottery_id = $lott->id;
|
|
$order->issue_num = $issueNum;
|
|
$order->shop_id = $customer->shop_id;
|
|
$order->lottery_type_id = $lott->lottery_type_id;
|
|
$order->order_sn = Order::makeOrderSn();
|
|
$order->play_type = $playType;
|
|
$order->bets_num = $betsNum;
|
|
$order->bets_expect_num = $computeInfo['expect_bets'];
|
|
$order->zhu_num = $computeInfo['zhu_num'];
|
|
$order->piao_num = count($piaos);
|
|
$order->money = $computeInfo['money'];
|
|
$order->prize_min = $computeInfo['prize_min'];
|
|
$order->prize_max = $computeInfo['prize_max'];
|
|
$order->pay_state = PayState::UNPAID;
|
|
$order->pass_mode = $passModeKeys;
|
|
$order->odds_close_time = $oddsCloseTime;
|
|
$order->odds_early_close_time = $earlyTime;
|
|
$order->odds_late_close_time = $lateTime;
|
|
$order->type = $type;
|
|
$order->type_mode = $fadanSecret;
|
|
$order->type_desc = $fadanDesc;
|
|
$order->odds = $odds;
|
|
if ($type == OrderType::UNION) {
|
|
$pieceMoney = $order->money / $union_piece_total;
|
|
$order->union_piece_total = $union_piece_total;
|
|
$order->union_piece_buy = $union_piece_buy;
|
|
$order->union_piece_self = $union_piece_buy;
|
|
$order->union_piece_keep = $union_piece_keep;
|
|
$order->union_keep = $union_keep;
|
|
$order->union_brokerage = $union_brokerage;
|
|
$order->union_piece_money = $pieceMoney;
|
|
$order->union_money = $pieceMoney * ($union_piece_buy + $union_piece_keep);
|
|
}
|
|
$order->created_date = date('Ymd');
|
|
// 设置合作相关的数据
|
|
$order->setCooperateInfo($lott);
|
|
$order->save();
|
|
|
|
// 如果是合买,更新自己的pid
|
|
if ($order->type == OrderType::UNION) {
|
|
$order->pid = $order->id;
|
|
$order->save();
|
|
}
|
|
|
|
// 创建组合数据
|
|
$this->createZuhe($betsInfos, $order->id, null);
|
|
|
|
$orderOdds = [];
|
|
foreach ($bjdcOdds as $match) {
|
|
|
|
$orderOdds[] = [
|
|
'order_id' => $order->id,
|
|
'bjdc_sfgg_odds_id' => $match->id,
|
|
'odds_id' => $match->odds_id,
|
|
'match_id' => $match->match_id,
|
|
'created_at' => date('Y-m-d H:i:s'),
|
|
'updated_at' => date('Y-m-d H:i:s'),
|
|
];
|
|
}
|
|
OrderBjdcSfggResult::insert($orderOdds);
|
|
|
|
DB::commit();
|
|
return $order;
|
|
} catch (JingCaiException $e) {
|
|
DB::rollBack();
|
|
Log::error('bjdc::order::create ValidateException: ' . $e);
|
|
throw $e;
|
|
} catch (\Exception $e) {
|
|
DB::rollBack();
|
|
Log::error('bjdc::order::create Exception: ' . $e);
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
private function createZuhe($betsInfo, $orderId, $optimizeZuhe = [])
|
|
{
|
|
if ($optimizeZuhe) {
|
|
foreach ($optimizeZuhe as $item) {
|
|
$orderZuhe = new OrderBjdcSfggZuhe();
|
|
$orderZuhe->order_id = $orderId;
|
|
$orderZuhe->jczq_odds_ids = $item['ids'];
|
|
$orderZuhe->info = $item['info'];
|
|
$orderZuhe->bets_num = $item['bets_num'];
|
|
$orderZuhe->repeat_num = Arr::get($item, 'repeat_num', 1);
|
|
$orderZuhe->save();
|
|
}
|
|
return;
|
|
}
|
|
foreach ($betsInfo as $item) {
|
|
$orderZuhe = new OrderBjdcSfggZuhe();
|
|
$orderZuhe->order_id = $orderId;
|
|
$orderZuhe->bjdc_sfgg_odds_ids = $item['ids'];
|
|
$orderZuhe->info = $item['info'];
|
|
$orderZuhe->bets_num = $item['bets_num'];
|
|
$orderZuhe->save();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 跟单
|
|
* @param $data
|
|
* @param Customer $customer
|
|
* @return Order
|
|
* @throws \Throwable
|
|
*/
|
|
public function copyOrder(Customer $customer, Order $od, $data)
|
|
{
|
|
ThrowException::run('不支持跟单');
|
|
}
|
|
|
|
public function showOrder(Customer $customer, Order $order)
|
|
{
|
|
$order->sellings = [];
|
|
// 截止后公开
|
|
if ($order->type_mode == 1 && ($order->type == OrderType::GENDAN || $order->type == OrderType::UNION)) {
|
|
$isTypeModel1 = true;
|
|
|
|
// 合买，是自己时，全部可见
|
|
if ($order->type == OrderType::UNION) {
|
|
if ($order->customer_id == $customer->id) {
|
|
$isTypeModel1 = false;
|
|
}
|
|
}
|
|
|
|
// 跟单：如果是自己跟自己，全部可见
|
|
if ($order->type == OrderType::GENDAN) {
|
|
if ($order->customer_id == $customer->id && $order->p_order->customer_id == $customer->id) {
|
|
$isTypeModel1 = false;
|
|
}
|
|
}
|
|
// 发单：如果是自己跟自己，全部可见
|
|
if ($order->type == OrderType::FADAN) {
|
|
if ($order->customer_id == $customer->id) {
|
|
$isTypeModel1 = false;
|
|
}
|
|
}
|
|
$order->sellings = $this->getOrderOdds($order, $isTypeModel1);
|
|
} else {
|
|
if ($order->customerCanSeeSellings($customer)) {
|
|
$order->sellings = $this->getOrderOdds($order);
|
|
}
|
|
}
|
|
if (!$order->sellings) {
|
|
$odds = $order->odds;
|
|
$jclqOddsIds = array_keys($odds);
|
|
$jclqOdds = BjdcSfggOdds::whereIn('id', $jclqOddsIds)
|
|
->where('close_time', '>', date('Y-m-d H:i:s'))
|
|
->first();
|
|
if (!$jclqOdds) {
|
|
$order->sellings = $this->getOrderOdds($order);
|
|
}
|
|
}
|
|
|
|
$order->chang_num = count($order->sellings);
|
|
$names = [];
|
|
foreach ($order->pass_mode as $val) {
|
|
$names[] = str_replace('.', '串', $val);
|
|
}
|
|
$order->pass_mode_names = $names;
|
|
|
|
$order->play_name = $order->lottery->name;
|
|
|
|
unset($order->lottery);
|
|
|
|
return $order;
|
|
}
|
|
|
|
private function getOrderOdds(Order $order, $isTypeModel1 = false)
|
|
{
|
|
/** @var Lottery $lottery */
|
|
$lottery = $order->lottery;
|
|
$earlyTime = $lottery->earlySecond();
|
|
|
|
$odds = $order->odds;
|
|
$bjdcOddsIds = array_keys($odds);
|
|
|
|
$bjdcOdds = BjdcSfggOdds::select([
|
|
'bjdc_sfgg_odds.id',
|
|
'bjdc_sfgg_odds.issue_num',
|
|
'bjdc_sfgg_odds.play_num',
|
|
'bjdc_sfgg_odds.bd_competition_name',
|
|
'bjdc_sfgg_odds.bd_competition_name_full',
|
|
'bjdc_sfgg_odds.bd_home_team_name',
|
|
'bjdc_sfgg_odds.bd_home_team_name_full',
|
|
'bjdc_sfgg_odds.bd_away_team_name',
|
|
'bjdc_sfgg_odds.bd_away_team_name_full',
|
|
DB::raw('close_time as real_close_time'),
|
|
])
|
|
->whereIn('id', $bjdcOddsIds)
|
|
->orderBy('bjdc_sfgg_odds.play_num', 'asc')
|
|
->get();
|
|
|
|
$currentDate = date('Y-m-d H:i:s');
|
|
$result = [];
|
|
foreach ($bjdcOdds as $item) {
|
|
$jczqResult = null;
|
|
if (in_array($order->lottery_state, Order::kaiJiangHouStates())) {
|
|
$jczqResult = BjdcSfggResult::where('bjdc_sfgg_odds_id', $item->id)->first();
|
|
}
|
|
$item->vs_b = $item->bd_home_team_name;
|
|
$item->vs_m = 'vs';
|
|
$item->vs_a = $item->bd_away_team_name;
|
|
$item->play_items = $this->getOrderPlayItems($order, $item, $jczqResult);
|
|
$item->half_time_score = '';
|
|
$item->full_time_score = '';
|
|
if ($jczqResult) {
|
|
$item->half_time_score = $jczqResult->half_time_score;
|
|
$item->full_time_score = $jczqResult->full_time_score;
|
|
}
|
|
$item->lottery_close_time = date('Y-m-d H:i:s', strtotime($item->real_close_time) - $earlyTime);
|
|
if ($isTypeModel1) {
|
|
if ($item->lottery_close_time > $currentDate) {
|
|
$result[] = new \stdClass();
|
|
} else {
|
|
$result[] = $item;
|
|
}
|
|
} else {
|
|
$result[] = $item;
|
|
}
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
private function getOrderPlayItems(Order $order, $bjdcOddsItem, $jczqResult)
|
|
{
|
|
$odds = $order->odds;
|
|
$buyOddsItem = Arr::get($odds, $bjdcOddsItem->id);
|
|
$playTypeNames = $this->playTypeNames();
|
|
$result = [];
|
|
|
|
foreach ($playTypeNames as $playType => $name) {
|
|
$buyPlayData = Arr::get($buyOddsItem, $playType);
|
|
if (!$buyPlayData) {
|
|
continue;
|
|
}
|
|
$resultPlayTypeItem = [];
|
|
foreach ($buyPlayData as $resultField => $odds) {
|
|
|
|
$wined = false;
|
|
|
|
$buyField = str_replace('_odds', '_field', $playType);
|
|
if ($jczqResult && $jczqResult->{$buyField} == $resultField) {
|
|
$wined = true;
|
|
}
|
|
|
|
$resultPlayTypeItem[] = [
|
|
'odds_value' => $odds,
|
|
'odds_name' => $resultField,
|
|
'name' => sprintf('%s(%s)', $this->getResultFieldName($playType, $resultField), $odds),
|
|
'wined' => $wined
|
|
];
|
|
}
|
|
$winResult = '';
|
|
$resultField = str_replace('_odds', '_name', $playType);
|
|
if ($jczqResult && $jczqResult->{$resultField}) {
|
|
$winResult = $jczqResult->{$resultField};
|
|
}
|
|
//dump($resultField,$playType,$playTypeNames,$jczqResult->toArray());
|
|
|
|
$result[] = [
|
|
'win_result' => $winResult,
|
|
'play_type' => $playType,
|
|
'play_name' => $this->getPlayTypeName($playType),
|
|
'play_items' => $resultPlayTypeItem,
|
|
];
|
|
}
|
|
// dd($result);
|
|
return $result;
|
|
}
|
|
|
|
|
|
public function sellerShowOrder(Seller $seller, Order $order)
|
|
{
|
|
$order->sellings = [];
|
|
if ($order->sellerCanSeeSellings($seller)) {
|
|
$order->sellings = $this->getOrderOdds($order);
|
|
}
|
|
$order->chang_num = count($order->sellings);
|
|
$names = [];
|
|
foreach ($order->pass_mode as $val) {
|
|
$names[] = str_replace('.', '串', $val);
|
|
}
|
|
$order->pass_mode_names = $names;
|
|
|
|
$order->play_name = $order->lottery->name;
|
|
|
|
unset($order->lottery);
|
|
|
|
return $order;
|
|
}
|
|
|
|
public function chaiPiao(Order $order)
|
|
{
|
|
|
|
$piaoList = [];
|
|
return $piaoList;
|
|
}
|
|
}
|