video_server/Modules/Manage/Controllers/FinanceController.php

<?php

namespace Modules\Manage\Controllers;

use App\Constants\CommonConstant;
use App\Model\PaymentAttrModel;
use App\Model\PaymentModel;
use App\Repositories\Criterias\OrderLimitCriteria;
use App\Repositories\Criterias\PaymentAttrCriteria;
use App\Repositories\Criterias\PaymentAttrLimitCriteria;
use App\Repositories\Criterias\PaymentLimitCriteria;
use App\Repositories\Criterias\PaymentTypeLimitCriteria;
use App\Repositories\OrderRepository;
use App\Repositories\PaymentAttrRepository;
use App\Repositories\PaymentTypeRepository;
use App\Repositories\Service\PaymentService;
use App\Repositories\VipRepository;
use Hyperf\Validation\Contract\ValidatorFactoryInterface;
use Modules\Manage\Responses\CommonPagesResponse;
use Modules\Manage\Responses\CommonSuccessPkResponse;
use Modules\Manage\Responses\PaymentSuccessUidResponse;

class FinanceController extends BaseController
{
    /**
     * 支付通道列表
     *
     * @param ValidatorFactoryInterface $validatorFactory
     * @param OrderRepository $orderRepository
     * @return mixed|CommonPagesResponse
     */
    public function paymentList(ValidatorFactoryInterface $validatorFactory)
    {
        $inputData = $this->getJsonData();

        $rules = [
            'page' => 'nullable|integer',
            'page_size' => 'nullable|integer',
            'status' => 'nullable|in:1,2',
            'name' => 'nullable|string'
        ];
        $validator = $validatorFactory->make($inputData, $rules);
        if ($validator->fails()) {
            // 如果有错误（可能是多个信息），这里只取第一个错误信息返回.
            return json_fail($validator->errors()->first());
        }

        $orders = [
            ['created_at', 'DESC'],
        ];
        $pageSize = $inputData['page_size'] ?? CommonConstant::PAGE_SIZE;
        if ($pageSize > 500) {
            $pageSize = CommonConstant::PAGE_SIZE;
        }
        $page = format_page($inputData['page'] ?? 1);
        // 注意，单例分页一定要克隆一个（保证前面没用使用到paginate);
        $field = ['id', 'name', 'pay_code', 'status', 'created_at', 'updated_at', 'partner_id'];
        $payment = make(OrderRepository::class)->pushCriteria(new PaymentLimitCriteria($inputData))->pushCriteria(new OrderLimitCriteria($orders))->paginate($pageSize,
            $field, $page);
        return new CommonPagesResponse($payment);
    }

    /**
     * 支付通道添加
     *
     * @param ValidatorFactoryInterface $validatorFactory
     * @return mixed|PaymentSuccessUidResponse
     */
    public function paymentAdd(ValidatorFactoryInterface $validatorFactory)
    {
        $inputData = $this->getJsonData();

        $rules = [
            'name' => 'required|string',
            'pay_code' => 'required|string',
            'partner_id' => 'required|string',
        ];
        $validator = $validatorFactory->make($inputData, $rules);
        if ($validator->fails()) {
            // 如果有错误（可能是多个信息），这里只取第一个错误信息返回.
            return json_fail($validator->errors()->first());
        }

        $setarr = [
            'name' => $inputData['name'],
            'status' => 1,
            'pay_code' => $inputData['pay_code'],
            'partner_id' => $inputData['partner_id'],
        ];
        $result = make(OrderRepository::class)->create($setarr);
        if (!$result) {
            return json_fail('创建失败');
        } else {
            $logSubject = '添加一个支付通道,通道名字:' . $inputData['name'];
            $logSvalue = $result->id;
            $logDbData = [
                'after_items' => [
                    $result->toArray(),
                ],
                'before_items' => [],
            ];
            $this->log($logSubject, $logSvalue, $logDbData);

            return new PaymentSuccessUidResponse($result->manager_id);
        }
    }


    /**
     * 支付类型
     * @param ValidatorFactoryInterface $validatorFactory
     * @return mixed
     */
    public function paymentAttr(ValidatorFactoryInterface $validatorFactory)
    {
        $inputData = $this->getJsonData();
        $rules = [
            'page' => 'nullable|integer',
            'page_size' => 'nullable|integer',
            'pay_type' => 'nullable|integer',
            'status' => 'nullable|in:1,2',
            'pay_code' => 'nullable',
            'type_name' => 'nullable|string'
        ];
        $pageSize = $inputData['page_size'] ?? CommonConstant::PAGE_SIZE;
        if ($pageSize > 500) {
            $pageSize = CommonConstant::PAGE_SIZE;
        }
        $page = format_page($inputData['page'] ?? 1);
        $validator = $validatorFactory->make($inputData, $rules);
        if ($validator->fails()) {
            // 如果有错误（可能是多个信息），这里只取第一个错误信息返回.
            return json_fail($validator->errors()->first());
        }
        $orders = [
            ['created_at', 'DESC'],
        ];
        $paymentAttr = make(PaymentAttrRepository::class)
            ->pushCriteria(new PaymentAttrCriteria($inputData))
            ->pushCriteria(new PaymentAttrLimitCriteria($orders))
            ->paginate($pageSize, ['*'], $page);

        return new CommonPagesResponse($paymentAttr);
    }

    /**
     * 查询所有的
     * @return mixed
     */
    public function paymentAttrAll()
    {
        return json_success(PaymentAttrModel::query()
            ->select('uid', 'type_name', 'pay_code')
            ->get()->groupBy('pay_code'));
    }

    /**
     * 添加
     * @param ValidatorFactoryInterface $validatorFactory
     * @return mixed
     */
    public function createPaymentAttr(ValidatorFactoryInterface $validatorFactory)
    {
        $inputData = $this->getJsonData();
        $rules = [
            'pay_code' => 'required',
            'type_name' => 'required',
            'code' => 'required'
        ];
        $validator = $validatorFactory->make($inputData, $rules);
        if ($validator->fails()) {
            // 如果有错误（可能是多个信息），这里只取第一个错误信息返回.
            return json_fail($validator->errors()->first());
        }
        // 查询是否有通道
        $paymentModel = make(PaymentModel::class)->where('uid', $inputData['pay_code'])
            ->first();
        if (!$paymentModel) {
            return json_fail('该支付通道不存在!');
        }
        $data = $inputData;
        $data['pay_code'] = $paymentModel->uid;
        $res = PaymentAttrModel::query()->create($data);
        if (!$res) {
            return json_fail('创建失败');
        }
        return json_success('创建成功');
    }

    /**
     * 修改
     * @param ValidatorFactoryInterface $validatorFactory
     * @return mixed
     */
    public function updatePaymentAttr(ValidatorFactoryInterface $validatorFactory)
    {
        $inputData = $this->getJsonData();
        $rules = [
            'uid' => 'required',
            'pay_code' => 'nullable',
            'type_name' => 'nullable',
            'code' => 'nullable'
        ];
        $validator = $validatorFactory->make($inputData, $rules);
        if ($validator->fails()) {
            // 如果有错误（可能是多个信息），这里只取第一个错误信息返回.
            return json_fail($validator->errors()->first());
        }
        $paymentAttrModel = PaymentAttrModel::query()->where('uid', $inputData['uid'])->first();
        if (!$paymentAttrModel) {
            return json_fail('该支付类型不存在!');
        }
        $paymentAttrModel->pay_code = $inputData['pay_code'] ?? $paymentAttrModel->pay_code;
        $paymentAttrModel->type_name = $inputData['type_name'] ?? $paymentAttrModel->type_name;
        $paymentAttrModel->code = $inputData['code'] ?? $paymentAttrModel->code;
        if (!$paymentAttrModel->save()) {
            return json_fail('修改失败!');
        }
        return json_success('修改成功!');
    }

    /**
     * 删除
     * @param ValidatorFactoryInterface $validatorFactory
     * @return mixed
     */
    public function deletePaymentAttr(ValidatorFactoryInterface $validatorFactory)
    {
        $inputData = $this->getJsonData();
        $rules = [
            'uid' => 'required',
        ];
        $validator = $validatorFactory->make($inputData, $rules);
        if ($validator->fails()) {
            // 如果有错误（可能是多个信息），这里只取第一个错误信息返回.
            return json_fail($validator->errors()->first());
        }
        $paymentAttrModel = PaymentAttrModel::query()->where('uid', $inputData['uid'])->first();
        if (!$paymentAttrModel) {
            return json_fail('该支付类型不存在!');
        }
        if (!$paymentAttrModel->delete()) {
            return json_fail('删除失败!');
        }

        return json_success('删除成功!');
    }

    /**
     * 支付通道修改
     *
     * @param ValidatorFactoryInterface $validatorFactory
     * @return mixed|PaymentSuccessUidResponse
     */
    public function paymentUpdate(ValidatorFactoryInterface $validatorFactory)
    {
        $inputData = $this->getJsonData();

        $rules = [
            'id' => 'required|integer',
            'status' => 'nullable|in:1,2',
            'name' => 'nullable|string',
            'pay_code' => 'nullable|string',
            'partner_id' => 'nullable|string',
        ];
        $validator = $validatorFactory->make($inputData, $rules);
        if ($validator->fails()) {
            // 如果有错误（可能是多个信息），这里只取第一个错误信息返回.
            return json_fail($validator->errors()->first());
        }

        $payment = make(OrderRepository::class)->findBy('id', $inputData['id']);
        if (empty($payment)) {
            return json_fail(trans('common.err_resource_not_found'));
        }

        $oldPayment = clone $payment;

        if (!empty($inputData['status'])) {
            $payment->status = $inputData['status'];
        }

        if (!empty($inputData['name'])) {
            $payment->name = $inputData['name'];
        }

        if (!empty($inputData['pay_code'])) {
            $payment->pay_code = $inputData['pay_code'];
        }

        if (!empty($inputData['partner_id'])) {
            $payment->partner_id = $inputData['partner_id'];
        }

        $result = $payment->save();
        if (!$result) {
            return json_fail('修改失败');
        } else {
            $logSubject = '修改一个支付通道,通道名字:' . $payment->name;
            $logSvalue = $payment->id;
            $logDbData = [
                'after_items' => [
                    $payment->toArray(),
                ],
                'before_items' => [
                    $oldPayment->toArray(),
                ],
            ];
            $this->log($logSubject, $logSvalue, $logDbData);
            return new PaymentSuccessUidResponse($payment->id);
        }
    }

    /**
     * 通道支付类型列表
     *
     * @param ValidatorFactoryInterface $validatorFactory
     * @return mixed|CommonPagesResponse
     */
    public function paymentTypeList(ValidatorFactoryInterface $validatorFactory)
    {
        $inputData = $this->getJsonData();

        $rules = [
            'page' => 'nullable|integer',
            'page_size' => 'nullable|integer',
            'status' => 'nullable|in:1,2',
            'pay_type' => 'nullable|in:1,2,3',
            'payment_uid' => 'nullable|string',
        ];
        $validator = $validatorFactory->make($inputData, $rules);
        if ($validator->fails()) {
            // 如果有错误（可能是多个信息），这里只取第一个错误信息返回.
            return json_fail($validator->errors()->first());
        }

        $orders = [
            ['weights', 'DESC'],
        ];
        $pageSize = $inputData['page_size'] ?? CommonConstant::PAGE_SIZE;
        if ($pageSize > 500) {
            $pageSize = CommonConstant::PAGE_SIZE;
        }
        $page = format_page($inputData['page'] ?? 1);

        // 注意，单例分页一定要克隆一个（保证前面没用使用到paginate);
        $field = [
            'uid',
            'name',
            'pay_type',
            'payment_attr_uid',
            'status',
            'created_at',
            'updated_at',
            'code',
            'limit_type',
            'limit',
            'remark',
            'payment_uid',
            'belong_device',
            'weights'
        ];
        $paymentType = make(PaymentTypeRepository::class)
            ->pushCriteria(new PaymentTypeLimitCriteria($inputData))
            ->pushCriteria(new OrderLimitCriteria($orders))
            ->paginate($pageSize, $field, $page);

        if ($paymentType->isNotEmpty()) {
            $payment = make(OrderRepository::class)->getPaymentData(['name', 'uid'])->keyBy('uid');

            foreach ($paymentType->items() as &$item) {
                $item->paymetn_name = $payment[$item->payment_uid]->name;
            }
        }

        return new CommonPagesResponse($paymentType);
    }

    /**
     * 通道支付类型添加
     *
     * @param ValidatorFactoryInterface $validatorFactory
     * @return mixed|PaymentSuccessUidResponse
     */
    public function paymentTypeAdd(ValidatorFactoryInterface $validatorFactory)
    {
        $inputData = $this->getJsonData();

        $rules = [
            'name' => 'required|string',
            'code' => 'required|string',
            'limit_type' => 'required|integer',
            'pay_type' => 'required|in:1,2,3,5',
            'limit' => 'required|string',
            'weights' => 'required|integer',
            'remark' => 'nullable|string',
            'belong_device' => 'nullable',
        ];
        $validator = $validatorFactory->make($inputData, $rules);
        if ($validator->fails()) {
            // 如果有错误（可能是多个信息），这里只取第一个错误信息返回.
            return json_fail($validator->errors()->first());
        }
        // 查询数据
        $paymentAttrModel = PaymentAttrModel::query()
            ->where('uid', $inputData['code'])
            ->first();
        if (!$paymentAttrModel) {
            return json_fail('该类型不存在!');
        }
        $setarr = [
            'name' => $inputData['name'],
            'status' => 2,
            'payment_uid' => $paymentAttrModel->pay_code,
            'pay_type' => $inputData['pay_type'],
            'code' => $paymentAttrModel->code,
            'payment_attr_uid' => $paymentAttrModel->uid,
            'limit_type' => $inputData['limit_type'],
            'limit' => $inputData['limit'],
            'weights' => $inputData['weights'],
            'remark' => $inputData['remark'],
            'belong_device' => $inputData['belong_device'] ?? null,
        ];
        $result = make(PaymentTypeRepository::class)->create($setarr);
        if (!$result) {
            return json_fail('创建失败');
        } else {
            $logSubject = '添加一个通道类型, 名字:' . $inputData['name'];
            $logSvalue = $result->id;
            $logDbData = [
                'after_items' => [
                    $result->toArray(),
                ],
                'before_items' => [],
            ];
            $this->log($logSubject, $logSvalue, $logDbData);

            return new PaymentSuccessUidResponse($result->uid);
        }
    }

    /**
     * 通道支付类型修改
     *
     * @param ValidatorFactoryInterface $validatorFactory
     * @return mixed|PaymentSuccessUidResponse
     */
    public function paymentTypeUpdate(ValidatorFactoryInterface $validatorFactory)
    {
        $inputData = $this->getJsonData();

        $rules = [
            'name' => "required|string",
            'uid' => "required",
            'code' => 'required|string',
            'limit_type' => 'required|integer',
            'pay_type' => 'required|in:1,2,3,5',
            'limit' => 'required|string',
            'weights' => 'required|integer',
            'remark' => 'nullable|string',
            'status' => 'nullable|in:1,2',
            'belong_device' => 'nullable',
        ];
        $validator = $validatorFactory->make($inputData, $rules);
        if ($validator->fails()) {
            // 如果有错误（可能是多个信息），这里只取第一个错误信息返回.
            return json_fail($validator->errors()->first());
        }

        $paymentType = make(PaymentTypeRepository::class)->findBy('uid', $inputData['uid']);
        if (empty($paymentType)) {
            return json_fail(trans('common.err_resource_not_found'));
        }
        $oldPaymentType = clone $paymentType;
        if (!empty($inputData['code'])) {
            // 查询数据
            $paymentAttrModel = PaymentAttrModel::query()
                ->where('uid', $inputData['code'])
                ->first();
            if (!$paymentAttrModel) {
                return json_fail('该类型不存在!');
            }
            $paymentType->payment_uid = $paymentAttrModel->pay_code;
            $paymentType->code = $paymentAttrModel->code;
            $paymentType->payment_attr_uid = $paymentAttrModel->uid;
        }

        if (!empty($inputData['limit_type'])) {
            $paymentType->limit_type = $inputData['limit_type'];
        }
        if (!empty($inputData['name'])) {
            $paymentType->name = $inputData['name'];
        }

        if (!empty($inputData['pay_type'])) {
            $paymentType->pay_type = $inputData['pay_type'];
        }

        if (!empty($inputData['limit'])) {
            $paymentType->limit = $inputData['limit'];
        }

        if (!empty($inputData['weights'])) {
            $paymentType->weights = $inputData['weights'];
        }

        if (!empty($inputData['remark'])) {
            $paymentType->remark = $inputData['remark'];
        }
        if (!empty($inputData['status'])) {
            $paymentType->status = $inputData['status'];
        }
        if (!empty($inputData['belong_device'])) {
            $paymentType->belong_device = $inputData['belong_device'];
        } else {
            $paymentType->belong_device = null;
        }
        $result = $paymentType->save();
        if (!$result) {
            return json_fail('修改失败');
        } else {
            $logSubject = '修改一个通道类型, 名字:' . $paymentType->name;
            $logSvalue = $paymentType->uid;
            $logDbData = [
                'after_items' => [
                    $paymentType->toArray(),
                ],
                'before_items' => [
                    $oldPaymentType->toArray(),
                ],
            ];
            $this->log($logSubject, $logSvalue, $logDbData);
            make(PaymentService::class)->delPaymentTypeCache();
            return new PaymentSuccessUidResponse($paymentType->uid);
        }
    }

    /**
     * 通道支付类型删除
     *
     * @param ValidatorFactoryInterface $validatorFactory
     * @return mixed|PaymentSuccessUidResponse
     */
    public function paymentTypeDelete(ValidatorFactoryInterface $validatorFactory)
    {
        $inputData = $this->getJsonData();

        $rules = [
            'uid' => 'required|string',
        ];
        $validator = $validatorFactory->make($inputData, $rules);
        if ($validator->fails()) {
            // 如果有错误（可能是多个信息），这里只取第一个错误信息返回.
            return json_fail($validator->errors()->first());
        }

        $paymentType = make(PaymentTypeRepository::class)->findBy('uid', $inputData['uid']);
        if (empty($paymentType)) {
            return json_fail(trans('common.err_resource_not_found'));
        }

        $oldManagerType = clone $paymentType;
        $result = $paymentType->delete();
        if (!$result) {
            return json_fail('删除失败');
        } else {
            $logSubject = '删除一个通道类型,名字:' . $paymentType->name;
            $logSvalue = $oldManagerType->manager_id;
            $logDbData = [
                'after_items' => [
                ],
                'before_items' => [
                    $oldManagerType->toArray(),
                ],
            ];
            $this->log($logSubject, $logSvalue, $logDbData);
            make(PaymentService::class)->delPaymentTypeCache();
            return new PaymentSuccessUidResponse($inputData['uid']);
        }
    }

    /**
     * 通道下拉
     *
     * @return CommonPagesResponse
     */
    public function paymentDown()
    {
        $payment = make(OrderRepository::class)->getPaymentData(['name', 'uid'])->keyBy('uid');
        return new CommonPagesResponse($payment);
    }
}