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
     * @throws Exception
     */
    public function updateModel(array $data, string $id)
    {
        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);

            AdminTranslationService::saveTranslation(
                $data['model_name'],
                $data['en_name'] ?? '',
                $data['tw_name'] ?? '',
                $model->id,
                10
            );
            DB::commit();
            return $model;
        } catch (Exception $e) {
            DB::rollBack();
            throw $e;
        }
    }

    // 更新
    public function updateData($data, $id)
    {
        $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
     * @throws Exception
     */
    public function createModel(array $data)
    {
        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'];
            $en_name = $data['en_name'] ?? '';
            $tw_name = $data['tw_name'] ?? '';

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

            // 验证
            $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('');
            }

            // 更新车位id
            $where = [
                'pattern_id' => $pattern_id,
                'space_id' => $parking_space_id
            ];
            $pattern_space_id = ParkingPatternSpace::query()->where($where)
                ->value('id');

            $save = [
                'pattern_id' => $pattern_id,
                'parking_space_id' => $parking_space_id,
                'parking_space_type' => $parking_space_type_id
            ];
            $ParkingPatternSpaceService = (new ParkingPatternSpaceService(
                $this->logService
            ));
            if ($pattern_space_id) {
                $ParkingPatternSpaceService->updateData(
                    $pattern_space_id,
                    $save['parking_space_type']
                );
            } else {
                $ParkingPatternSpaceService->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('pattern_id', $pattern_id)->delete();
    }

    public function updateDataModel($id, $field)
    {
        try {
            DB::beginTransaction();
            $model = ParkingPatternModel::query()->findOrFail($id);
            $oldValues = $model->toArray();
            $update = [
                $field => 1,
                'updated_at' => get_datetime()
            ];
            $model->update($update);
            $this->logService->logUpdated(
                $model,
                $oldValues,
                'parking_pattern.update'
            );
            DB::commit();
            return $model;
        } catch (Exception $e) {
            DB::rollBack();
            throw $e;
        }
    }
}