parking_manage_system/app/Http/Controllers/Admin/ParkingAttendantController.php

<?php

namespace App\Http\Controllers\Admin;

use App\Exceptions\CustomException;
use App\Models\ParkingAdminUser;
use App\Services\ApiResponseService;
use App\Services\ParkingAdminUserService;
use Exception;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;
use Illuminate\Validation\ValidationException;

class ParkingAttendantController extends BaseController
{
    protected string $menuUri = 'parkingAttendant';

    /**
     * @var ParkingAdminUserService
     */
    protected ParkingAdminUserService $service;

    /**
     * @param ApiResponseService      $responseService
     * @param ParkingAdminUserService $service
     */
    public function __construct(
        ApiResponseService $responseService,
        ParkingAdminUserService $service
    ) {
        parent::__construct($responseService);
        $this->service = $service;
    }


    /**
     * @return JsonResponse
     */
    public function search(): JsonResponse
    {
        try {
            $data = [
                'member_type_list' => get_select_data(
                    ParkingAdminUserService::$memberType
                )
            ];
            return $this->responseService->success($data);
        } catch (Exception $e) {
            $m_prefix = __('exception.exception_handler.resource');
            return $this->responseService->systemError(
                $m_prefix . '：' . $e->getMessage()
            );
        }
    }

    public function index(Request $request): JsonResponse
    {
        try {
            $query = ParkingAdminUser::query();

            if ($request->has('name')) {
                $name = $request->input('name');
                if (!empty($name)) {
                    $query->where('name', 'like', "%{$name}%");
                }
            }

            if ($request->has('phone')) {
                $phone = $request->input('phone');
                if (!empty($phone)) {
                    $query->where('phone', $phone);
                }
            }

            if ($request->has('member_type')) {
                $member_type = $request->input('member_type');
                if (!empty($member_type)) {
                    $query->where('member_type', $member_type);
                }
            }

            // 分页
            $page = $request->input('page', 1);
            $perPage = $request->input('per_page', 10);
            $query->orderBy('id');
            $total = $query->count();
            $memberType = ParkingAdminUserService::$memberType;

            $items = $query->latest()->forPage($page, $perPage)->get()->each(
                function ($item) use ($memberType) {
                    $item['member_type'] = $memberType[$item['member_type']];
                    return $item;
                }
            );

            return $this->responseService->success([
                'items'     => $items,
                'total'     => $total,
                'page'      => $page,
                'per_page'  => $perPage,
                'last_page' => ceil($total / $perPage),
            ]);
        } catch (Exception $e) {
            $m_prefix = __('exception.exception_handler.resource');
            return $this->responseService->systemError(
                $m_prefix . '：' . $e->getMessage()
            );
        }
    }

    /**
     * @param Request $request
     * @return JsonResponse
     * @throws CustomException
     * @throws ValidationException
     */
    public function store(Request $request): JsonResponse
    {
        try {
            $this->saveValidator($request->all());
            $this->service->createModel($request->all());
            return $this->responseService->success(
                null,
                __('admin.save_succeeded')
            );
        } catch (ValidationException|CustomException $e) {
            throw $e;
        } catch (Exception $e) {
            return $this->responseService->systemError(
                __('admin.operation_failed') . '：'
                . $e->getMessage()
            );
        }
    }

    /**
     * @param array $data
     * @param int   $id
     * @return void
     */
    protected function saveValidator(array $data, int $id = 0): void
    {
        $rules = [
            'name'        => 'required',
            'phone'       => 'required',
            'member_type' => 'required',
        ];
        $messages = [
            'name.required'        => __(
                'validation.parking_attendant.n_empty'
            ),
            'phone.required'       => __(
                'validation.parking_attendant.p_empty'
            ),
            'member_type.required' => __(
                'validation.parking_attendant.m_empty'
            ),
        ];
        $model = ParkingAdminUser::query();

        if ($id) {
            $this->validateId($id, ParkingAdminUser::class);
            $model->where([
                ['name', '=', $data['name']],
                ['id', '<>', $id]
            ]);
        } else {
            $model->where('name', $data['name']);
        }

        if ($model->exists()) {
            throw new CustomException(
                __('validation.parking_attendant.name_exists')
            );
        }

        $validator = Validator::make($data, $rules, $messages);

        if ($validator->fails()) {
            throw new ValidationException($validator);
        }
    }

    public function edit($id): JsonResponse
    {
        try {
            $this->validateId($id, ParkingAdminUser::class);
            $item = ParkingAdminUser::query()->findOrFail($id);
            $data = [
                'item' => $item,
                'member_type_list' => get_select_data(
                    ParkingAdminUserService::$memberType
                ),
            ];
            return $this->responseService->success($data);
        } catch (Exception $e) {
            return $this->responseService->systemError(
                __('exception.get_data_failed') . '：' . $e->getMessage()
            );
        }
    }

    /**
     * @param Request $request
     * @param string  $id
     * @return JsonResponse
     * @throws CustomException
     * @throws ValidationException
     */
    public function update(Request $request, string $id): JsonResponse
    {
        try {
            $data = $request->all();
            $this->saveValidator($data, $id);
            $this->service->updateModel($data, $id);
            return $this->responseService->success(
                null,
                __('admin.update_succeeded')
            );
        } catch (ValidationException|CustomException $e) {
            throw $e;
        } catch (Exception $e) {
            return $this->responseService->systemError(
                __('admin.operation_failed') . '：'
                . $e->getMessage()
            );
        }
    }

    /**
     * @param string $id
     * @return JsonResponse
     * @throws ValidationException
     */
    public function destroy(string $id): JsonResponse
    {
        try {
            $this->validateId($id, ParkingAdminUser::class);
            $this->service->deleteModel($id);
            return $this->responseService->success(
                null,
                __('admin.delete_succeeded')
            );
        } catch (ValidationException $e) {
            throw $e;
        } catch (Exception $e) {
            return $this->responseService->systemError(
                __('admin.operation_failed') . '：'
                . $e->getMessage()
            );
        }
    }
}