parking_manage_system/app/Services/ParkingPatternService.php

<?php

namespace App\Services;

use App\Models\ParkingPattern as ParkingPatternModel;
use App\Models\ParkingPatternSpace;
use App\Models\ParkingSpace;
use App\Models\ParkingSpaceType;
use Exception;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\DB;

class ParkingPatternService extends BaseService
{
    private static array $statusArr    = ['disabled', 'enable'];
    private static array $isDefaultArr = ['no', 'yes'];

    public function __construct(OperationLogService $logService)
    {
        parent::__construct($logService);
        $this->logService->menuTitle = 'model_manage';
    }

    /**
     * @return array|string[]
     */
    public static function getStatus(): array
    {
        $statusArr = self::$statusArr;
        foreach ($statusArr as $key => $value) {
            $statusArr[$key] = __('admin.' . $value);
        }
        return $statusArr;
    }

    /**
     * @return array|string[]
     */
    public static function getIsDefaultArr(): array
    {
        $arr = self::$isDefaultArr;
        foreach ($arr as $key => $value) {
            $arr[$key] = __('service.reservation.' . $value);
        }
        return $arr;
    }

    /**
     * @param array  $data
     * @param string $id
     * @return Builder|Model
     * @throws Exception
     */
    public function updateModel(array $data, string $id): Builder|Model
    {
        try {
            DB::beginTransaction();
            $existsWhere = [
                ['name', '=', $data['model_name']],
                ['id', '<>', $id]
            ];
            if (ParkingPatternModel::query()->where($existsWhere)->exists()) {
                throw new Exception(__('service.parking_pattern.name_exists'));
            }
            $model = $this->updateData($data, $id);
            DB::commit();
            return $model;
        } catch (Exception $e) {
            DB::rollBack();
            throw $e;
        }
    }

    // 更新
    public function updateData($data, $id): Builder|Model
    {
        $model = ParkingPatternModel::query()->findOrFail($id);
        $oldValues = $model->toArray();
        $update = [
            'name'          => $data['model_name'],
            'admin_user_id' => $data['admin_user_id'],
            'updated_at'    => get_datetime()
        ];
        if (isset($data['status']) && is_numeric($data['status'])) {
            $update['status'] = $data['status'];
        }
        if (isset($data['change']) && is_numeric($data['change'])) {
            $update['change'] = $data['change'];
        }
        if (isset($data['release']) && is_numeric($data['release'])) {
            $update['release'] = $data['release'];
        }
        if (isset($data['is_default']) && is_numeric($data['is_default'])) {
            $update['is_default'] = $data['is_default'];
        }
        $model->update($update);
        $this->logService->logUpdated(
            $model,
            $oldValues,
            'parking_pattern.update'
        );
        return $model;
    }

    /**
     * @param array $data
     * @return Builder|Model
     * @throws Exception
     */
    public function createModel(array $data): Builder|Model
    {
        try {
            DB::beginTransaction();
            if (ParkingPatternModel::query()->where('name', $data['model_name'])
                ->exists()
            ) {
                throw new Exception(__('service.parking_pattern.name_exists'));
            }
            $model = $this->createData($data);
            DB::commit();
            return $model;
        } catch (Exception $e) {
            DB::rollBack();
            throw $e;
        }
    }

    // 创建
    public function createData($data)
    {
        $model = ParkingPatternModel::query()->create([
            'name'          => $data['model_name'],
            'admin_user_id' => $data['admin_user_id'],
            'status'        => $data['status'] ?? 1,
            'change'        => $data['change'] ?? 0,
            'release'       => $data['release'] ?? 0,
            'is_default'    => $data['is_default'] ?? 0,
            'created_at'    => get_datetime(),
            'updated_at'    => get_datetime()
        ]);

        $this->logService->logCreated($model, 'parking_pattern.create');

        return $model;
    }

    /**
     * 保存
     * @param $data
     * @return bool
     */
    public function saveModel($data): bool
    {
        try {
            DB::beginTransaction();

            $model_name = $data['model_name'];
            $parking_space_number = $data['parking_space_number'];
            $parking_space_type = $data['parking_space_type'];

            $pattern_id = ParkingPatternModel::query()->where('name', $model_name)->value('id');
            if ($pattern_id) {
                $this->updateData($data, $pattern_id);
            } else {
                $this->createData($data);
                $pattern_id = ParkingPatternModel::query()->where('name', $model_name)
                    ->value('id');
            }

            // 验证
            $parking_space_id = ParkingSpace::getValueId($parking_space_number);
            if (empty($parking_space_id)) {
                throw new Exception('');
            }
            $parking_space_type_id = ParkingSpaceType::getValueId(
                $parking_space_type
            );
            if (empty($parking_space_type_id)) {
                throw new Exception('');
            }

            $pattern_space_id = ParkingPatternSpace::query()->where(
                'space_id',
                $parking_space_id
            )->value('id');

            $save = [
                'pattern_id'    => $pattern_id,
                'parking_space_id'      => $parking_space_id,
                'parking_space_type' => $parking_space_type_id
            ];
            if ($pattern_space_id) {
                $ParkingPatternSpace = ParkingPatternSpace::query()->findOrFail($pattern_space_id);
                $oldValues = $ParkingPatternSpace->toArray();
                $ParkingPatternSpace->update($save);
                $this->logService->logUpdated(
                    $ParkingPatternSpace,
                    $oldValues,
                    'parking_pattern_space.update'
                );
            } else {
                (new ParkingPatternSpaceService($this->logService))->createData($save);
            }

            DB::commit();
            return true;
        } catch (Exception $e) {
            DB::rollBack();
            return false;
        }
    }

    public function deleteModel(int $id): bool
    {
        try {
            DB::beginTransaction();

            $model = ParkingPatternModel::query()->findOrFail($id);

            $this->logService->logDeleted($model, 'parking_pattern.delete');

            $model->delete();

            $this->delPatternSpace($id);

            DB::commit();
            return true;
        } catch (Exception $e) {
            DB::rollBack();
            throw $e;
        }
    }

    private function delPatternSpace(int $pattern_id): void
    {
        $oldAdminRoleMenu = ParkingPatternSpace::getData($pattern_id);
        $this->logService->logDeletedData(
            new ParkingPatternSpace(),
            'parking_pattern_space.delete',
            $oldAdminRoleMenu
        );
        ParkingPatternSpace::query()->where('camera_id', $pattern_id)->delete();
    }
}