strprfcrm/app/Http/Controllers/UserController.php

<?php

namespace App\Http\Controllers;

use App\Http\Requests\User\DeleteUser;
use App\Http\Requests\User\StoreProfile;
use App\Http\Requests\User\StoreUser;
use App\Models\Order;
use App\Models\Permission;
use App\Models\Reclamation;
use App\Models\ReclamationStatus;
use App\Models\Role;
use App\Models\User;
use App\Models\UserNotificationSetting;
use App\Services\Access\AccessService;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Hash;

class UserController extends Controller
{
    protected array $data = [
        'active' => 'users',
        'title'  => 'Пользователи',
        'id'        => 'users',
        'header'    => [
            'id'            => 'ID',
            'email'         => 'Логин/email',
            'name'          => 'ФИО',
            'phone'         => 'Телефон',
            'role'          => 'Роль',
            'app_installed' => 'Приложение',
            'created_at'    => 'Дата создания',
            'deleted_at'    => 'Дата Удаления',
        ],
        'searchFields' => [
            'name',
            'phone',
            'email',
        ],
        'ranges' => [],
        'filters' => [],
    ];


    /**
     * Display a listing of the resource.
     */
    public function index(Request $request)
    {
        session(['gp_users' => $request->query()]);
        $nav = $this->startNavigationContext($request);

        $model = new User;
        $this->createFilters($model, 'role');
        $this->createDateFilters($model, 'created_at');

        if (isset($this->data['filters']['role']['values'])) {
            foreach ($this->data['filters']['role']['values'] as $key => $value) {
                $this->data['filters']['role']['values'][$key] = \App\Models\Role::NAMES[$key] ?? $value;
            }
        }

        $q = $model::query();
        $this->acceptFilters($q, $request);
        $this->acceptSearch($q, $request);
        $this->setSortAndOrderBy($model, $request);
//        $q->withTrashed();
        $this->applyStableSorting($q);
        $this->data['users'] = $q->paginate($this->data['per_page'])->withQueryString();
        $this->data['nav'] = $nav;

        return view('users.index', $this->data);
    }

    /**
     * Show the form for creating a new resource.
     */
    public function create(Request $request)
    {
        $nav = $this->resolveNavToken($request);
        $this->rememberNavigation($request, $nav);
        $this->data['nav'] = $nav;
        $this->data['back_url'] = $this->navigationBackUrl(
            $request,
            $nav,
            route('user.index', session('gp_users', []))
        );
        $this->data['user'] = null;
        $this->prepareNotificationSettingsData(null);
        $this->preparePermissionSettingsData(null);
        return view('users.edit', $this->data);
    }

    /**
     * Store a newly or update existing created resource in storage.
     */
    public function store(StoreUser $request)
    {
        $validated = $request->validated();
        $settingsData = $this->extractNotificationSettings($request);
        $hasPermissionEffects = array_key_exists('permission_effects', $validated);
        $permissionEffects = $validated['permission_effects'] ?? [];

        unset($validated['notification_settings']);
        unset($validated['permission_effects']);

        if (!empty($validated['role_id'])) {
            $role = Role::query()->find($validated['role_id']);
            $validated['role'] = $role?->slug ?? $validated['role'] ?? Role::MANAGER;
        } elseif (!empty($validated['role'])) {
            $role = Role::query()->where('slug', $validated['role'])->first();
            $validated['role_id'] = $role?->id;
        }

        if(!empty($validated['password'])) {
            $validated['password'] = Hash::make($validated['password']);
        } else {
            unset($validated['password']);
        }

        $user = null;
        DB::transaction(function () use ($validated, $settingsData, $hasPermissionEffects, $permissionEffects, &$user) {
            if(isset($validated['id'])) {
                User::query()
                    ->where('id', $validated['id'])
                    ->update($validated);
                $user = User::query()->find($validated['id']);
            } else {
                $user = User::query()->create($validated);
            }

            if ($user) {
                UserNotificationSetting::query()->updateOrCreate(
                    ['user_id' => $user->id],
                    $settingsData,
                );

                if ($hasPermissionEffects) {
                    $this->syncUserPermissionOverrides($user, $permissionEffects);
                }
            }
        });

        app(AccessService::class)->bumpCacheVersion();

        return redirect()->route('user.index')->with(['success' => 'Пользователь ' . $validated['name'] . ' сохранён!']);
    }

    /**
     * Display the specified resource.
     */
    public function show(Request $request, int $userId)
    {
        $nav = $this->resolveNavToken($request);
        $this->rememberNavigation($request, $nav);
        $this->data['nav'] = $nav;
        $this->data['back_url'] = $this->navigationBackUrl(
            $request,
            $nav,
            route('user.index', session('gp_users', []))
        );
        $this->data['user'] = User::query()
            ->where('id', $userId)
            ->withTrashed()
            ->first();
        $this->prepareNotificationSettingsData($this->data['user']);
        $this->preparePermissionSettingsData($this->data['user']);

        return view('users.edit', $this->data);
    }


    /**
     * Remove the specified resource from storage.
     */
    public function destroy(User $user, DeleteUser $request)
    {
        if($user->is($request->user())) {
            return redirect()->route('user.index')->with(['danger' => 'Нельзя удалить самого себя!']);
        } else {
            $user->delete();
            return redirect()->route('user.index')->with(['success' => 'Пользователь ' . $user->name . ' удалён!']);
        }
    }

    public function profile(Request $request)
    {
        $this->data['current_menu'] = 'profile';
        $this->data['user'] = $request->user();
        return view('users.profile', $this->data);
    }

    public function storeProfile(StoreProfile $request)
    {
        $data = $request->validated();

        unset($data['current_password'], $data['password']);
        if(
            isset($request->current_password)
            && isset($request->password)
            && (Hash::check($request->current_password, $request->user()->password))) {
            $data['password'] = Hash::make($request->password);
        }

        User::query()->where('id', '=', $request->user()->id)->update($data);

        return redirect()->route('user.profile')->with(['success' => 'Профиль обновлён!']);
    }

    public function deleteProfile(Request $request)
    {
        User::query()->where('id', '=', $request->user()->id)->delete();
        User::clearFcmToken((int)$request->user()->id);
        Auth::logout();
        return redirect()->route('login')->with(['success' => 'Профиль удалён!']);
    }

    public function undelete(int $userId)
    {
        User::query()->where('id', '=', $userId)->restore();
        return redirect()->route('user.show', $userId)->with(['success' => 'Пользователь восстановлен!']);
    }

    public function impersonate(Request $request, User $user)
    {
        $currentUser = $request->user();

        if ($currentUser->id === $user->id) {
            return redirect()->back()->with(['danger' => 'Нельзя войти от имени самого себя!']);
        }

        if ($user->trashed()) {
            return redirect()->back()->with(['danger' => 'Нельзя войти от имени удалённого пользователя!']);
        }

        if (session()->has('impersonator_id')) {
            return redirect()->back()->with(['danger' => 'Вы уже вошли от имени другого пользователя.']);
        }

        $impersonatorId = $currentUser->id;

        Auth::login($user);
        $request->session()->put('impersonator_id', $impersonatorId);
        $request->session()->regenerate();

        return redirect()->route('home')->with(['success' => 'Вы вошли от имени пользователя ' . $user->name . '.']);
    }

    public function leaveImpersonation(Request $request)
    {
        $impersonatorId = (int) session('impersonator_id');

        if (!$impersonatorId) {
            return redirect()->back()->with(['danger' => 'Режим impersonate не активен.']);
        }

        $impersonator = User::query()->find($impersonatorId);

        if (!$impersonator) {
            if ($request->user()) {
                User::clearFcmToken((int)$request->user()->id);
            }
            Auth::logout();
            $request->session()->invalidate();
            $request->session()->regenerateToken();

            return redirect()->route('login')->with(['danger' => 'Не удалось вернуться к исходному пользователю.']);
        }

        abort_unless($impersonator->resolvedRoleSlug() === Role::ADMIN, 403);

        Auth::login($impersonator);
        $request->session()->forget('impersonator_id');
        $request->session()->regenerate();

        return redirect()->route('user.index')->with(['success' => 'Вы вернулись в аккаунт администратора.']);
    }

    private function prepareNotificationSettingsData(?User $user): void
    {
        $this->data['orderStatusOptions'] = Order::STATUS_NAMES;
        $this->data['orderStatusColors'] = Order::STATUS_COLOR;
        $this->data['reclamationStatusOptions'] = Reclamation::STATUS_NAMES;
        $this->data['reclamationStatusColors'] = ReclamationStatus::STATUS_COLOR;
        $this->data['scheduleSourceOptions'] = ['platform' => 'Площадки', 'reclamation' => 'Рекламации'];
        $this->data['chatSourceOptions'] = ['platform' => 'Площадки', 'reclamation' => 'Рекламации'];
        $this->data['notificationChannels'] = ['browser' => 'Браузер', 'push' => 'Push', 'email' => 'Email'];

        $this->data['disabledChannels'] = [
            'browser' => false,
            'push' => !$user || !$user->token_fcm,
            'email' => !$user || !$user->notification_email || !filter_var($user->notification_email, FILTER_VALIDATE_EMAIL),
        ];

        if (!$user) {
            $this->data['notificationSettings'] = UserNotificationSetting::defaultsForUser(0);
            return;
        }

        $settings = UserNotificationSetting::query()->firstOrCreate(
            ['user_id' => $user->id],
            UserNotificationSetting::defaultsForUser($user->id),
        );

        $this->data['notificationSettings'] = $settings->toArray();
    }

    private function preparePermissionSettingsData(?User $user): void
    {
        $this->data['roles'] = Role::query()
            ->where('is_active', true)
            ->orderBy('sort')
            ->orderBy('name')
            ->pluck('name', 'id')
            ->all();

        $this->data['permissionGroups'] = Permission::getGroupedForUi();
        $this->data['permissionEffects'] = [];
        $this->data['rolePermissionEffects'] = [];

        if (!$user) {
            return;
        }

        $this->data['permissionEffects'] = $user->permissions()
            ->pluck('user_permissions.effect', 'permissions.id')
            ->all();

        if ($user->roleModel) {
            $this->data['rolePermissionEffects'] = $user->roleModel
                ->permissions()
                ->pluck('role_permissions.effect', 'permissions.id')
                ->all();
        }
    }

    private function syncUserPermissionOverrides(User $user, array $effects): void
    {
        if ($user->resolvedRoleSlug() === Role::ADMIN) {
            $user->permissions()->detach();
            return;
        }

        $permissions = Permission::query()
            ->whereIn('id', array_filter(array_keys($effects), 'is_numeric'))
            ->get();

        $sync = [];
        foreach ($permissions as $permission) {
            $effect = $effects[$permission->id] ?? null;
            if (in_array($effect, ['allow', 'deny'], true)) {
                $sync[$permission->id] = ['effect' => $effect];
            }
        }

        $user->permissions()->sync($sync);
    }

    private function extractNotificationSettings(Request $request): array
    {
        $input = $request->input('notification_settings', []);
        $settings = [
            'order_settings' => [],
            'reclamation_settings' => [],
            'schedule_settings' => [],
            'chat_settings' => [],
        ];

        $orderStatuses = array_keys(Order::STATUS_NAMES);
        $reclamationStatuses = array_keys(Reclamation::STATUS_NAMES);
        $scheduleSources = ['platform', 'reclamation'];
        $chatSources = ['platform', 'reclamation'];
        $channels = ['browser', 'push', 'email'];

        foreach ($orderStatuses as $statusId) {
            foreach ($channels as $channel) {
                $settings['order_settings'][$statusId][$channel] = isset($input['orders'][$statusId][$channel]);
            }
        }

        foreach ($reclamationStatuses as $statusId) {
            foreach ($channels as $channel) {
                $settings['reclamation_settings'][$statusId][$channel] = isset($input['reclamations'][$statusId][$channel]);
            }
        }

        foreach ($scheduleSources as $source) {
            foreach ($channels as $channel) {
                $settings['schedule_settings'][$source][$channel] = isset($input['schedule'][$source][$channel]);
            }
        }

        foreach ($chatSources as $source) {
            foreach ($channels as $channel) {
                $settings['chat_settings'][$source][$channel] = isset($input['chat'][$source][$channel]);
            }
        }

        return $settings;
    }


}