dwbs-user-api/app/Services/Dwbs/ShopOrderService.php

<?php

namespace App\Services\Dwbs;

use App\Repositories\Criteria\Dwbs\ShopOrderCriteria;
use App\Repositories\Eloquent\Dwbs\ShopOrderRepositoryEloquent;
use App\Repositories\Enums\CheckStatusEnum;
use App\Repositories\Enums\Dwbs\ShopOrderStatusEnum;
use App\Repositories\Enums\Dwbs\UserJifenTypeEnum;
use App\Repositories\Enums\ModelStatusEnum;
use App\Repositories\Enums\ResponseCodeEnum;
use App\Repositories\Models\Base\User;
use App\Repositories\Models\Dwbs\ShopGood;
use App\Repositories\Models\Dwbs\ShopOrder;
use App\Repositories\Models\Dwbs\ShopOrderGood;
use App\Repositories\Models\Dwbs\UserAddress;
use App\Repositories\Models\Dwbs\UserJifen;
use App\Repositories\Presenters\Dwbs\ShopOrderPresenter;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\DB;

class ShopOrderService
{
    /**
     * @var ShopOrderRepositoryEloquent
     */
    private $repository;

    /**
     * ShopOrderService constructor.
     *
     * @param ShopOrderRepositoryEloquent $shopOrderRepositoryEloquent
     */
    public function __construct(ShopOrderRepositoryEloquent $repository)
    {
        $this->repository = $repository;
    }

    /**
     * @param Request $request
     *
     * @return mixed
     * @throws \Prettus\Repository\Exceptions\RepositoryException
     */
    public function handleList(Request $request)
    {
        $this->repository->pushCriteria(new ShopOrderCriteria($request));
        $this->repository->setPresenter(ShopOrderPresenter::class);

        return $this->repository->searchListsPage();
    }

    /**
     * @param $id
     *
     * @return \Illuminate\Database\Eloquent\Model
     */
    public function handleProfile($id)
    {
        $this->repository->setPresenter(ShopOrderPresenter::class);
        return $this->repository->searchBy($id);
    }

    /**
     * 礼品兑换
     * @param array $data
     *
     * @return mixed
     * @throws \Prettus\Validator\Exceptions\ValidatorException
     */
    public function handleStore($data)
    {
        //校检积分
        $goods = $data['goods'];
        $totalJifen = 0;
        $totalNums = 0;

        $user = User::query()->where('id', $data['user_id'])->where('status', ModelStatusEnum::OK)->select(['id', 'jifen'])->first();
        if (!$user) abort(ResponseCodeEnum::SERVICE_OPERATION_ERROR, '找不到该用户');

        $address = UserAddress::query()->where('id', $data['address_id'])->where('status', ModelStatusEnum::OK)->where('user_id', $user->id)->first();
        if (!$address) abort(ResponseCodeEnum::SERVICE_OPERATION_ERROR, '无效的收货地址');

        $com_goods = [];
        foreach ($goods as $good) {
            $goodModel = ShopGood::byIdGetOrder($good['id']);
            if (!$goodModel) abort("找不到该商品");

            if ($goodModel->nums < $good['nums']) abort(ResponseCodeEnum::SERVICE_OPERATION_ERROR, "{$goodModel->name}库存不足");
            $tj = bcmul($goodModel['jifen'], $good['nums'], 0);

            $com_goods[] = [
                'good_id' => $goodModel->id,
                'jifen' => $goodModel->jifen,
                'nums' => $good['nums'],
                'total_jifen' => $tj,
//                'model' => $goodModel
            ];

            $totalJifen = bcadd($tj, $totalJifen, 0);
            $totalNums += (int)$good['nums'];
        }

        if ((int)$data['jifen'] !== (int)$totalJifen) abort(ResponseCodeEnum::SERVICE_OPERATION_ERROR, '积分计算不正确');
        if ((int)$data['nums'] !== (int)$totalNums) abort(ResponseCodeEnum::SERVICE_OPERATION_ERROR, '商品数量计算不正确');
        if ($user->jifen < $totalJifen) abort(ResponseCodeEnum::SERVICE_OPERATION_ERROR, '积分不足');

//        //检测是否有超库存操作
//        Cache::lock("lock:shopOrder:has:kucun")->get(function () use ($com_goods) {
//            foreach ($com_goods as $good) {
//                $good_id = $good['good_id'];
//                //检测商品是否存在缓存
//                if (!Cache::has("model:good:nums:{$good_id}")) {
//                    ShopGood::reloadKuCun($good_id);
//                }
//            }
//            return true;
//        });

        $isChaoKuCun = true;
        $kuCunGoods = [];
        foreach ($com_goods as $good) {
            $good_id = $good['good_id'];
            $good_nums = $good['nums'];


            //检测商品是否存在缓存[没有缓存的时候可能会超卖]
//            if (!Cache::has("model:good:nums:{$good_id}")) {
//                ShopGood::reloadKuCun($good_id);
//            }

            $isChaoKuCun = Cache::lock("lock:shopOrder:good:{$good_id}")->get(function () use ($good_id, $good_nums) {
                $kuCunNums = Cache::get("model:good:nums:{$good_id}", 0);
                if (!$kuCunNums || $kuCunNums < $good_nums) {
                    return false;
                }

                Cache::decrement("model:good:nums:{$good_id}", $good_nums);
                return true;
            });

            if (!$isChaoKuCun) {
                //存在超库时恢复其他商品的库存
                foreach ($kuCunGoods as $g) {
                    $good_id = $g['good_id'];
                    $good_nums = $g['nums'];
                    Cache::lock("lock:shopOrder:good:{$good_id}")->get(function () use ($good_id, $good_nums) {
                        Cache::increment("model:good:nums:{$good_id}", $good_nums);
                        return true;
                    });
                }
                break;
            }

            $kuCunGoods[] = $good;
        }

        if (!$isChaoKuCun) abort(ResponseCodeEnum::SERVICE_OPERATION_ERROR, '库存不足');

        $order = DB::transaction(function () use ($com_goods, $user, $totalJifen, $totalNums, $data, $address) {
            $order = ShopOrder::query()->create([
                'order_no' => ShopOrder::makeNo(),
                'day' => date('Y-m-d'),
                'user_id' => $user['id'],
                'order_time' => Carbon::now()->toDateTimeString(),
                'jifen' => $totalJifen,
                'nums' => $totalNums,
                'address_id' => $address['id'],
                'sjr_name' => $address['name'],
                'sjr_mobile' => $address['mobile'],
                'sjr_mobile_encryption' => $address['mobile_encryption'],
                'sjr_mobile_code' => $address['mobile_code'],
                'sjr_address_province' => $address['province'],
                'sjr_address_city' => $address['city'],
                'sjr_address_area' => $address['area'],
                'sjr_address' => $address['address'],
                'check_status' => CheckStatusEnum::WAIT,
                'status' => ShopOrderStatusEnum::wait_check
            ]);
            $user = User::query()->where('id', $data['user_id'])->first();
            $user->jifen = bcsub($user->jifen, $totalJifen, 0);
            $user->xiaofei_jifen = bcadd($user->xiaofei_jifen, $totalJifen, 0);
            $user->save();

            UserJifen::query()->create([
                'day' => date('Y-m-d'),
                'user_id' => $user->id,
                'jifen' => -$totalJifen,
                'type' => UserJifenTypeEnum::lipinduihuan,
                'source_id' => $order->id,
                'source_type' => ShopOrder::class,
                'user_jifen' => $user->jifen,
                'is_reward' => ModelStatusEnum::PAUSE,
                'status' => ModelStatusEnum::OK,
            ]);

            foreach ($com_goods as $good) {
                ShopOrderGood::query()->create([
                    'order_id' => $order->id,
                    'user_id' => $order->user_id,
                    'good_id' => $good['good_id'],
                    'nums' => $good['nums'],
                    'total_jifen' => $good['total_jifen'],
                    'jifen' => $good['jifen'],
                ]);
                ShopGood::query()->where('id', $good['good_id'])->decrement('nums', $good['nums']);
                ShopGood::query()->where('id', $good['good_id'])->increment('duihuan_nums', $good['nums']);

            }

            $order['user_jifen'] = $user->jifen;

            return $order;
        });

        return $order;
    }

    /**
     * @param array $data
     *
     * @return mixed
     * @throws \Prettus\Validator\Exceptions\ValidatorException
     */
    public function handleUpdate($data)
    {
        $shopOrder = ShopOrder::query()->where('id', $data['id'])->first();
        $shopOrder->fill($data);
        $shopOrder->save();
        return $shopOrder;
    }

    /**
     * @param Request $request
     *
     * @return mixed
     * @throws \Prettus\Validator\Exceptions\ValidatorException
     */
    public function handleDelete($id)
    {
        return $this->repository->delete($id);
    }

    /**
     * 选项
     * @param Request $request
     * @return \Illuminate\Contracts\Pagination\LengthAwarePaginator|\Illuminate\Support\Collection|mixed
     * @throws \Prettus\Repository\Exceptions\RepositoryException
     */
    public function handleSelectOptions(Request $request)
    {
        $this->repository->pushCriteria(new ShopOrderCriteria($request));
        return $this->repository->all(['id', 'name']);
    }

    /**
     * 批量删除
     * @param $ids
     * @return mixed
     */
    public function handleBatchDelete($ids)
    {
        return $this->repository->whereIn('id', $ids)->delete();
    }

    /**
     * @param Request $request
     *
     * @return mixed
     * @throws \Prettus\Repository\Exceptions\RepositoryException
     */
    public function handleAll(Request $request)
    {
        $this->repository->pushCriteria(new ShopOrderCriteria($request));
        $this->repository->setPresenter(ShopOrderPresenter::class);

        return $this->repository->get();
    }

    /**
     * @param Request $request
     *
     * @return mixed
     * @throws \Prettus\Repository\Exceptions\RepositoryException
     */
    public function handleIds(Request $request)
    {
        $this->repository->pushCriteria(new ShopOrderCriteria($request));
        return $this->repository->pluck('id');
    }

    /**
     * 修改订单地址
     * @param $data
     * @return true
     */
    public function handleUpdateAddress($data)
    {
        $order = ShopOrder::query()->where('id', $data['id'])->where('user_id', login_user_id())->first();
        if (!$order) abort(ResponseCodeEnum::SERVICE_OPERATION_ERROR, '找不到该订单');

        if ($order->status === ShopOrderStatusEnum::close) abort(ResponseCodeEnum::SERVICE_OPERATION_ERROR, '该订单已关闭');
        if ($order->status !== ShopOrderStatusEnum::wait_check) abort(ResponseCodeEnum::SERVICE_OPERATION_ERROR, '该订单已锁定');


        $address = UserAddress::query()->where('id', $data['address_id'])->where('status', ModelStatusEnum::OK)->where('user_id', $order->user_id)->first();
        if (!$address) abort(ResponseCodeEnum::SERVICE_OPERATION_ERROR, '无效的收货地址');

        $order->fill([
            'address_id' => $address['id'],
            'sjr_name' => $address['name'],
            'sjr_mobile' => $address['mobile'],
            'sjr_mobile_encryption' => $address['mobile_encryption'],
            'sjr_mobile_code' => $address['mobile_code'],
            'sjr_address_province' => $address['province'],
            'sjr_address_city' => $address['city'],
            'sjr_address_area' => $address['area'],
            'sjr_address' => $address['address'],
        ]);
        $order->save();
        return true;
    }


    /**
     * 关闭订单
     * @param $data
     * @return true
     */
    public function handleCloseOrder($order_id, $close_order_reason)
    {
        if (isAdminModule()) {
            $order = ShopOrder::query()->where('id', $order_id)->first();
        } else {
            $order = ShopOrder::query()->where('id', $order_id)->where('user_id', login_user_id())->first();
        }
        if (!$order) abort(ResponseCodeEnum::SERVICE_OPERATION_ERROR, '找不到该订单');

        if ($order->status === ShopOrderStatusEnum::close) abort(ResponseCodeEnum::SERVICE_OPERATION_ERROR, '该订单已关闭');
        if ($order->status !== ShopOrderStatusEnum::wait_check) abort(ResponseCodeEnum::SERVICE_OPERATION_ERROR, '该订单已锁定');

        DB::transaction(function () use ($order, $close_order_reason) {
            $order->status = ShopOrderStatusEnum::close;
            $order->close_order_reason = $close_order_reason;
            $order->save();

            $user = User::query()->where('id', $order->user_id)->first();

            $user->jifen = bcadd($user->jifen, $order->jifen, 0);
            $user->xiaofei_jifen = bcsub($user->xiaofei_jifen, $order->jifen, 0);
            $user->save();

            UserJifen::query()->create([
                'day' => date('Y-m-d'),
                'user_id' => $user->id,
                'jifen' => $order->jifen,
                'type' => UserJifenTypeEnum::dingdanzuofei,
                'source_id' => $order->id,
                'source_type' => ShopOrder::class,
                'user_jifen' => $user->jifen,
                'is_reward' => ModelStatusEnum::PAUSE,
                'status' => ModelStatusEnum::OK,
            ]);

            $shopOrderGoods = ShopOrderGood::query()->where('order_id', $order->id)->where('status', ModelStatusEnum::OK)->get();
            foreach ($shopOrderGoods as $good) {
                $good->status = ModelStatusEnum::PAUSE;
                $good->save();

                $shopGood = ShopGood::query()->where('id', $good->good_id)->first();
                if ($shopGood) {
                    $shopGood->nums += $good->nums;
                    $shopGood->duihuan_nums -= $good->nums;
                    $shopGood->save();
                }
            }

            $order['user_jifen'] = $user->jifen;
        });

        return true;
    }

    /**
     * 批量审核
     * @param $ids
     * @param $data
     * @return bool
     */
    public function handleBatchCheck($ids, $data)
    {
        $db_nums = ShopOrder::query()->whereIn('id', $ids)->where('status', ShopOrderStatusEnum::wait_check)->where('check_status', CheckStatusEnum::WAIT)->count();
        if (count($ids) !== (int)$db_nums) {
            abort(ResponseCodeEnum::SERVICE_OPERATION_ERROR, '勾选中存在不满足条件的记录');
        }

        $orders = ShopOrder::query()->whereIn('id', $ids)->where('status', ShopOrderStatusEnum::wait_check)->where('check_status', CheckStatusEnum::WAIT)->get();

        $admin_id = login_admin_id();
        DB::transaction(function () use ($orders, $data, $admin_id) {
            foreach ($orders as $order) {
                $order->check_status = $data['check_status'];
                $order->check_admin_id = $admin_id;
                $order->check_remark = $data['check_remark'];
                $order->check_time = Carbon::now()->toDateTimeString();
                $order->status = ShopOrderStatusEnum::wait_send;
                $order->save();
            }
        });
        return true;
    }
}