ntspi-app/app/Containers/VikonIntegration/UI/WEB/Controllers/VikonController.php

<?php

namespace App\Containers\VikonIntegration\UI\WEB\Controllers;

use App\Containers\VikonIntegration\Actions\Auth\AuthenticateAction;
use App\Containers\VikonIntegration\Actions\CheckAccessAction;
use App\Containers\VikonIntegration\Actions\CheckVersionAction;
use App\Containers\VikonIntegration\Actions\SyncFilesAction;
use App\Containers\VikonIntegration\Actions\UpdateCoreAction;
use App\Containers\VikonIntegration\Actions\UpdatePartAction;
use App\Containers\VikonIntegration\Tasks\RefreshTokenTask;
use App\Containers\VikonIntegration\Tasks\ValidateTokenTask;
use App\Containers\VikonIntegration\UI\WEB\Requests\AuthenticateRequest;
use App\Containers\VikonIntegration\UI\WEB\Requests\UpdateModuleRequest;
use App\Containers\VikonIntegration\UI\WEB\Requests\UpdatePartRequest;
use App\Http\Controllers\Controller;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Session;

class VikonController extends Controller
{
    public function __construct(
        private readonly AuthenticateAction $auth,
        private readonly CheckAccessAction $checkAccess,
        private readonly CheckVersionAction $checkVersion,
        private readonly UpdateCoreAction $updateCore,
        private readonly SyncFilesAction $syncFiles,
        private readonly UpdatePartAction $updatePart,
        private readonly RefreshTokenTask $refreshToken,
        private readonly ValidateTokenTask $validateToken,
    ) {}

    public function index(): \Inertia\Response
    {
        $token = Session::get('vikon_access_token');
        $isAuth = $token ? $this->validateToken->run($token) : false;
        $parts = [];

        if ($isAuth && $token) {
            $accessResult = $this->checkAccess->run($token);
            $parts = $accessResult['parts'] ?? [];

            $versionResult = $this->checkVersion->run($token);
            if (!empty($versionResult['latest_version'])) {
                $this->writeVersionFile($versionResult['latest_version']);
            }
        }

        return inertia()->render('Dashboard/VikonUpdates/Index', [
            'is_authenticated' => $isAuth,
            'current_version' => app('vikon.version'),
            'modules' => config('vikon.modules'),
            'parts' => $parts,
            'vikon_api_domain' => config('vikon.api_domain'),
            'vikon_client_id' => config('vikon.client_id'),
        ]);
    }

    public function oauthCallback(Request $request): \Inertia\Response
    {
        $state = $request->query('state');
        $expectedState = Session::pull('oauth_state');

        if ($state && $expectedState && $state !== $expectedState) {
            Log::channel('vikon')->warning('Vikon OAuth CSRF mismatch');
        }

        $code = $request->query('code');
        if ($code) {
            try {
                $redirectUri = url('/vikon_core/update/index.php');
                $tokens = $this->auth->run($code, $redirectUri);
                Session::put('vikon_access_token', $tokens['access_token']);
                Session::put('vikon_refresh_token', $tokens['refresh_token']);
            } catch (\Throwable $e) {
                Log::channel('vikon')->error('OAuth callback failed', ['error' => $e->getMessage()]);
            }
        }

        $token = Session::get('vikon_access_token');
        $isAuth = $token ? $this->validateToken->run($token) : false;
        $parts = [];

        if ($isAuth && $token) {
            $accessResult = $this->checkAccess->run($token);
            $parts = $accessResult['parts'] ?? [];
        }

        return inertia()->render('Dashboard/VikonUpdates/Index', [
            'is_authenticated' => $isAuth,
            'current_version' => app('vikon.version'),
            'modules' => config('vikon.modules'),
            'parts' => $parts,
            'vikon_api_domain' => config('vikon.api_domain'),
            'vikon_client_id' => config('vikon.client_id'),
        ]);
    }

    public function authenticate(AuthenticateRequest $request): JsonResponse
    {
        try {
            $tokens = $this->auth->run(
                $request->validated('code'),
                $request->validated('redirect_uri')
            );
            Session::put('vikon_access_token', $tokens['access_token']);
            Session::put('vikon_refresh_token', $tokens['refresh_token']);

            return response()->json(['success' => true]);
        } catch (\Throwable $e) {
            return response()->json(['success' => false, 'message' => 'Ошибка авторизации'], 422);
        }
    }

    public function refreshToken(): JsonResponse
    {
        $refreshToken = Session::get('vikon_refresh_token');
        if (!$refreshToken) {
            return response()->json(['success' => false, 'message' => 'Нет refresh токена'], 401);
        }

        try {
            $tokens = $this->refreshToken->run($refreshToken);
            Session::put('vikon_access_token', $tokens['access_token']);
            Session::put('vikon_refresh_token', $tokens['refresh_token']);
            return response()->json(['success' => true]);
        } catch (\Throwable $e) {
            Session::forget(['vikon_access_token', 'vikon_refresh_token']);
            return response()->json(['success' => false, 'message' => 'Токен истёк'], 401);
        }
    }

    public function checkAccess(): JsonResponse
    {
        $token = Session::get('vikon_access_token');
        if (!$token) {
            return response()->json(['success' => false, 'requires_auth' => true], 401);
        }

        $result = $this->checkAccess->run($token);
        return response()->json($result);
    }

    public function updateModule(UpdateModuleRequest $request): JsonResponse
    {
        $token = Session::get('vikon_access_token');
        if (!$token) {
            return response()->json(['success' => false, 'requires_auth' => true], 401);
        }

        try {
            $message = $this->updateCore->run($request->validated('module_id'), $token);
            return response()->json(['success' => true, 'message' => $message]);
        } catch (\Throwable $e) {
            Log::channel('vikon')->error('Vikon update failed', ['error' => $e->getMessage()]);
            return response()->json(['success' => false, 'message' => $e->getMessage()], 500);
        }
    }

    public function syncFiles(UpdateModuleRequest $request): JsonResponse
    {
        $token = Session::get('vikon_access_token');
        if (!$token) {
            return response()->json(['success' => false, 'requires_auth' => true], 401);
        }

        try {
            $message = $this->syncFiles->run($request->validated('module_id'), $token);
            return response()->json(['success' => true, 'message' => $message]);
        } catch (\Throwable $e) {
            Log::channel('vikon')->error('Vikon sync failed', ['error' => $e->getMessage()]);
            return response()->json(['success' => false, 'message' => $e->getMessage()], 500);
        }
    }

    public function updatePart(UpdatePartRequest $request): JsonResponse
    {
        $token = Session::get('vikon_access_token');
        if (!$token) {
            return response()->json(['success' => false, 'requires_auth' => true], 401);
        }

        try {
            $result = $this->updatePart->run(
                $request->validated('module_id'),
                $request->validated('part'),
                $token
            );
            return response()->json($result);
        } catch (\Throwable $e) {
            Log::channel('vikon')->error('Vikon part update failed', ['error' => $e->getMessage()]);
            return response()->json(['success' => false, 'message' => $e->getMessage()], 500);
        }
    }

    public function logout(): JsonResponse
    {
        Session::forget(['vikon_access_token', 'vikon_refresh_token']);
        return response()->json(['success' => true]);
    }

    public function getAuthUrl(): JsonResponse
    {
        $state = \Illuminate\Support\Str::random(32);
        Session::put('oauth_state', $state);

        $redirectUri = route('dashboard.vikon-updates.callback');
        $url = config('vikon.auth_domain') . 'oauth2/authorize'
            . '?client_id=' . config('vikon.client_id')
            . '&redirect_uri=' . urlencode($redirectUri)
            . '&response_type=code'
            . '&state=' . $state;

        return response()->json(['url' => $url]);
    }

    private function writeVersionFile(string $version): void
    {
        $file = config('vikon.version_file');
        if ($file) {
            $dir = dirname($file);
            if (!is_dir($dir)) {
                mkdir($dir, 0755, true);
            }
            file_put_contents($file, $version);
        }
    }
}