bot-28/app/Http/Controllers/admin/ActivityReward.php

<?php

namespace App\Http\Controllers\admin;

use App\Constants\HttpStatus;
use App\Http\Controllers\Controller;
use App\Services\ActivityRewardService;
use Illuminate\Http\JsonResponse;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\ValidationException;
use Exception;
use App\Models\ActivityReward as ActivityRewardModel;
use App\Support\ActivityCatalog;
use Illuminate\Validation\Rule;

class ActivityReward extends Controller
{
    public function options(): JsonResponse
    {
        return $this->success(ActivityCatalog::options());
    }

    public function index(): JsonResponse
    {
        try {
            $params = request()->validate([
                'page' => ['required', 'integer', 'min:1'],
                'limit' => ['required', 'integer', 'min:1'],
                'title' => ['nullable', 'string'],
                'type' => ['nullable', 'string'],
                'platform' => ['nullable', 'string', 'in:pc,h5'],
                'status' => ['nullable', 'integer', 'in:0,1'],
                'lang' => ['nullable', 'string', 'max:10'],
                'game_category' => ['nullable', 'string', Rule::in(array_keys(ActivityCatalog::gameTypes()))],
            ]);
            $page = request()->input('page', 1);
            $limit = request()->input('limit', 10);
            $where = ActivityRewardService::getWhere(array_intersect_key($params, ['title' => true, 'type' => true]));
            $query = ActivityRewardModel::where($where);
            if (isset($params['status']) && $params['status'] !== '') {
                $query->where('status', (int)$params['status']);
            }
            if (isset($params['lang']) && $params['lang'] !== '') {
                $query->where('lang', $params['lang']);
            }
            if (isset($params['game_category']) && $params['game_category'] !== '') {
                $query->where('game_category', $params['game_category']);
            }
            if (isset($params['platform']) && $params['platform'] !== '') {
                $platform = strtoupper($params['platform']);
                $query->where(function ($platformQuery) use ($platform) {
                    $platformQuery->where('type', 2)
                        ->orWhereNull('publish_platforms')
                        ->orWhereJsonLength('publish_platforms', 0);
                    if ($platformQuery->getModel()->getConnection()->getDriverName() === 'sqlite') {
                        $platformQuery->orWhereRaw('EXISTS (SELECT 1 FROM json_each(publish_platforms) WHERE json_each.value = ?)', [$platform]);
                    } else {
                        $platformQuery->orWhereJsonContains('publish_platforms', $platform);
                    }
                });
            }
            $count = $query->count();
            $list = $query->orderByDesc('sort')->orderByDesc('id')
                ->forPage($page, $limit)->get()->toArray();
            foreach ($list as &$item) {
                if (!empty($item['params'])) {
                    $item['params'] = json_decode($item['params'], true);
                }
            }
            $result = ['total' => $count, 'data' => $list];
        } catch (ValidationException $e) {
            return $this->error(HttpStatus::CUSTOM_ERROR, $e->validator->errors()->first());
        } catch (Exception $e) {
            return $this->error($e->getCode(), $e->getMessage());
        }
        return $this->success($result);
    }


    public function store(): JsonResponse
    {
        DB::beginTransaction();
        try {
            $params = request()->validate([
                'id' => ['nullable', 'integer', 'min:1'],
                'title' => ['required', 'string', 'min:1', 'max:140'],
                'sub_title' => ['required', 'string', 'min:1', 'max:140'],
                'start_time' => ['required', 'date'],
                'end_time' => ['required', 'date', 'after_or_equal:start_time'],
                'detail_image' => ['required'],
                'pc_image' => ['required'],
                'detail_banner' => ['required'],
                'pc_banner' => ['required'],
                'status' => ['required', 'integer', 'min:0', 'max:1'],
                'type' => ['required', 'integer', 'min:1', 'max:6'],
                'lang' => ['required', 'string'],
                'content' => ['nullable', 'string'],
                'params' => ['nullable', 'array'],
                'game_category' => ['nullable', 'string', Rule::in(array_keys(ActivityCatalog::gameTypes()))],
            ]);
            $params = array_merge($params, array_intersect_key(request()->all(), ActivityRewardService::configurationDefaults()));
            // Wrong-mode inputs are rejected rather than silently disabling a limit.
            $params = array_merge($params, array_intersect_key(request()->all(), ['budget' => true, 'budget_used' => true]));
            $params['params'] = empty($params['params']) ? null : json_encode($params['params']);
            ActivityRewardService::submit($params);
            DB::commit();
        } catch (ValidationException $e) {
            DB::rollBack();
            return $this->error(HttpStatus::CUSTOM_ERROR, $e->validator->errors()->first());
        } catch (Exception $e) {
            DB::rollBack();
            return $this->error($e->getCode(), $e->getMessage());
        }
        return $this->success();
    }

    public function destroy(): JsonResponse
    {
        try {
            request()->validate([
                'id' => ['required', 'integer', 'min:1'],
            ]);
            $id = request()->input('id');
            ActivityRewardService::deleteAll(['id' => $id]);
            DB::commit();
        } catch (ValidationException $e) {
            DB::rollBack();
            return $this->error(HttpStatus::CUSTOM_ERROR, $e->validator->errors()->first());
        } catch (Exception $e) {
            DB::rollBack();
            return $this->error($e->getCode(), $e->getMessage());
        }
        return $this->success([], '删除成功');
    }
}