laravel_swoole/app/Services/System/DictionaryService.php

<?php

namespace App\Services\System;

use App\Models\System\Dictionary;
use App\Models\System\DictionaryItem;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Validator;

class DictionaryService
{
    public function getList(array $params): array
    {
        $query = Dictionary::query();

        if (!empty($params['keyword'])) {
            $query->where(function ($q) use ($params) {
                $q->where('name', 'like', '%' . $params['keyword'] . '%')
                    ->orWhere('code', 'like', '%' . $params['keyword'] . '%');
            });
        }

        if (isset($params['status']) && $params['status'] !== '') {
            $query->where('status', $params['status']);
        }

        $pageSize = $params['page_size'] ?? 20;
        $list = $query->orderBy('sort')->orderBy('id')->paginate($pageSize);

        return [
            'list' => $list->items(),
            'total' => $list->total(),
            'page' => $list->currentPage(),
            'page_size' => $list->perPage(),
        ];
    }

    public function getAll(): array
    {
        return Dictionary::where('status', true)
            ->orderBy('sort')
            ->get()
            ->toArray();
    }

    public function getById(int $id): ?Dictionary
    {
        return Dictionary::with('items')->find($id);
    }

    public function getByCode(string $code): ?Dictionary
    {
        return Dictionary::where('code', $code)->first();
    }

    public function getItemsByCode(string $code): array
    {
        $cacheKey = 'system:dictionary:' . $code;
        $items = Cache::get($cacheKey);

        if ($items === null) {
            $dictionary = Dictionary::where('code', $code)->first();
            if ($dictionary) {
                $items = DictionaryItem::where('dictionary_id', $dictionary->id)
                    ->where('status', true)
                    ->orderBy('sort')
                    ->get()
                    ->toArray();
                Cache::put($cacheKey, $items, 3600);
            } else {
                $items = [];
            }
        }

        return $items;
    }

    public function create(array $data): Dictionary
    {
        Validator::make($data, [
            'name' => 'required|string|max:100',
            'code' => 'required|string|max:50|unique:system_dictionaries,code',
        ])->validate();

        $dictionary = Dictionary::create($data);
        $this->clearCache();
        return $dictionary;
    }

    public function update(int $id, array $data): Dictionary
    {
        $dictionary = Dictionary::findOrFail($id);

        Validator::make($data, [
            'name' => 'sometimes|required|string|max:100',
            'code' => 'sometimes|required|string|max:50|unique:system_dictionaries,code,' . $id,
        ])->validate();

        $dictionary->update($data);
        $this->clearCache();
        return $dictionary;
    }

    public function delete(int $id): bool
    {
        $dictionary = Dictionary::findOrFail($id);
        DictionaryItem::where('dictionary_id', $id)->delete();
        $dictionary->delete();
        $this->clearCache();
        return true;
    }

    public function batchDelete(array $ids): bool
    {
        DictionaryItem::whereIn('dictionary_id', $ids)->delete();
        Dictionary::whereIn('id', $ids)->delete();
        $this->clearCache();
        return true;
    }

    public function batchUpdateStatus(array $ids, bool $status): bool
    {
        Dictionary::whereIn('id', $ids)->update(['status' => $status]);
        $this->clearCache();
        return true;
    }

    private function clearCache(): void
    {
        $codes = Dictionary::pluck('code')->toArray();
        foreach ($codes as $code) {
            Cache::forget('system:dictionary:' . $code);
        }
    }

    public function getItemsList(array $params): array
    {
        $query = DictionaryItem::query();

        if (!empty($params['dictionary_id'])) {
            $query->where('dictionary_id', $params['dictionary_id']);
        }

        if (isset($params['status']) && $params['status'] !== '') {
            $query->where('status', $params['status']);
        }

        $query->orderBy('sort')->orderBy('id');

        $pageSize = $params['page_size'] ?? 20;
        $list = $query->paginate($pageSize);

        return [
            'list' => $list->items(),
            'total' => $list->total(),
            'page' => $list->currentPage(),
            'page_size' => $list->perPage(),
        ];
    }

    public function createItem(array $data): DictionaryItem
    {
        Validator::make($data, [
            'dictionary_id' => 'required|exists:system_dictionaries,id',
            'label' => 'required|string|max:100',
            'value' => 'required|string|max:100',
        ])->validate();

        $item = DictionaryItem::create($data);
        $this->clearCache();
        return $item;
    }

    public function updateItem(int $id, array $data): DictionaryItem
    {
        $item = DictionaryItem::findOrFail($id);

        Validator::make($data, [
            'dictionary_id' => 'sometimes|required|exists:system_dictionaries,id',
            'label' => 'sometimes|required|string|max:100',
            'value' => 'sometimes|required|string|max:100',
        ])->validate();

        $item->update($data);
        $this->clearCache();
        return $item;
    }

    public function deleteItem(int $id): bool
    {
        $item = DictionaryItem::findOrFail($id);
        $item->delete();
        $this->clearCache();
        return true;
    }

    public function batchDeleteItems(array $ids): bool
    {
        DictionaryItem::whereIn('id', $ids)->delete();
        $this->clearCache();
        return true;
    }

    public function batchUpdateItemsStatus(array $ids, bool $status): bool
    {
        DictionaryItem::whereIn('id', $ids)->update(['status' => $status]);
        $this->clearCache();
        return true;
    }
}