src/Controller/ApiClientController.php line 389

  1. <?php
  3. namespace App\Controller;
  5. use App\AppHelper\Helper;
  6. use App\AppHelper\Settings;
  7. use App\Entity\Fonts;
  8. use App\Entity\Licences;
  9. use App\Entity\OAuth2UserConsent;
  10. use App\Entity\Product;
  11. use App\Entity\ProductLicense;
  12. use App\Entity\SystemSettings;
  13. use App\Entity\User;
  14. use App\Products\FlxZip;
  15. use DateTimeImmutable;
  16. use Doctrine\ORM\EntityManagerInterface;
  17. use Doctrine\ORM\Query\Expr\Join;
  18. use Exception;
  19. use Firebase\JWT\JWK;
  20. use Firebase\JWT\JWT;
  22. use League\Bundle\OAuth2ServerBundle\Model\Client;
  23. use League\Bundle\OAuth2ServerBundle\Model\Client as clientModel;
  24. use League\OAuth2\Server\AuthorizationServer;
  25. use League\OAuth2\Server\Exception\OAuthServerException;
  26. use Psr\Http\Message\ServerRequestInterface;
  27. use Sensio\Bundle\FrameworkExtraBundle\Configuration\IsGranted;
  28. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  29. use Symfony\Component\HttpFoundation\BinaryFileResponse;
  30. use Symfony\Component\HttpFoundation\JsonResponse;
  31. use Symfony\Component\HttpFoundation\RedirectResponse;
  32. use Symfony\Component\HttpFoundation\Response;
  33. use Symfony\Component\HttpFoundation\ResponseHeaderBag;
  34. use Symfony\Component\Routing\Annotation\Route;
  35. use Symfony\Component\Security\Core\User\UserInterface;
  36. use Symfony\Component\HttpFoundation\Request;
  37. use Symfony\Component\Serializer\SerializerInterface;
  38. use ZipArchive;
  40. class ApiClientController extends AbstractController
  41. {
  43.     use Settings;
  45.     public function __construct(
  46.         private readonly EntityManagerInterface $em,
  47.         private readonly SerializerInterface    $serializer
  48.     )
  49.     {
  51.     }
  53.     #[Route('/api/license/{license}', name: 'app_get_license_by_id')]
  54.     public function apiGetLicenseById(Request $request): JsonResponse
  55.     {
  56.         $license = $request->get('license');
  57.         $referer = $request->headers->get('X-Origin-URL');
  59.         $query = $this->em->createQueryBuilder()
  60.             ->from(ProductLicense::class, 'l')
  61.             ->select('l, u, ud')
  62.             ->leftJoin('l.user', 'u')
  63.             ->leftJoin('u.userdetails', 'ud')
  64.             ->andWhere('l.product_license =:product_license')
  65.             ->setParameter('product_license', $license);
  66.         $result = $query->getQuery()->getArrayResult();
  67.         $data = $result[0] ?? null;
  68.         $apiRedirect = [];
  69.         if($data){
  70.             $email =  $data['user']['email'];
  71.             $client = $this->em->getRepository(Client::class)->findOneBy(['name' => $email]);
  72.             $urls = $client->getRedirectUris();
  73.             $apiRedirect = implode(',', $urls);
  74.             $apiRedirect = explode(',', $apiRedirect);
  75.         }
  76.         $helper = Helper::instance();
  77.         $redirectArr = [];
  78.         foreach ($apiRedirect as $tmp) {
  79.             $redirectArr[] = $helper->removeTrailingSlash($tmp);
  80.         }
  81.         $referer = $helper->removeTrailingSlash($referer);
  82.         $license_status = false;
  83.         if(in_array($referer, $redirectArr)) {
  84.             $license_status = true;
  85.         }
  87.         $object = [
  88.             'id' => $license,
  89.             'license' => $license_status,
  90.             'urls' => $apiRedirect,
  91.             'referer' => $referer,
  92.             'cronjob' => $data['user']['userdetails']['cronjob'],
  93.             'user_active' => $data['user']['userdetails']['aktiv']
  94.         ];
  95.       //  return $this->json($object);
  96.         $json = $this->serializer->serialize($object, 'json');
  98.         return new JsonResponse($json, 200, [], true);
  99.     }
  102.     #[Route('/api/test', name: 'app_api_test')]
  103.     #[IsGranted('ROLE_OAUTH2_BASIC')]
  104.     public function apiTest(Request $request): Response
  105.     {
  107.         /** @var User $user */
  108.         $user = $this->getUser();
  109.         if ($user) {
  110.             $loggedInEmail = $user->getEmail();
  111.         } else {
  112.             $loggedInEmail = 'empty';
  113.         }
  114.         $callValidate = $this->validate_client($request);
  115.         $client = $callValidate['client'];
  116.         $clientUser = $callValidate['user'];
  117.         if (!$callValidate['status']) {
  118.             return $this->json([
  119.                 'error' => $callValidate['msg'],
  120.                 'error_description' => 'Client authentication failed',
  121.                 'message' => 'Client authentication failed'
  122.             ], 403);
  123.         }
  126.         return $this->json([
  127.             'message' => 'You successfully authenticated!',
  128.             'email' => $client->getName(),
  129.             'loggend_in_user' => $loggedInEmail,
  130.             'vorname' => $clientUser->getUserdetails()->getFirstName(),
  131.             'nachname' => $clientUser->getUserdetails()->getLastName(),
  132.             'scope' => explode(',', $callValidate['scopes']),
  133.         ], 200);
  134.     }
  136.     /**
  137.      * @param Fonts $fonts
  138.      * @return BinaryFileResponse|void
  139.      */
  140.     #[Route('/api/fonts/{id}/download', name: '_api_download_font')]
  141.     #[IsGranted('ROLE_OAUTH2_BASIC')]
  142.     public function api_font_download(Fonts $fonts)
  143.     {
  144.         $helper = Helper::instance();
  145.         $fontDir = $this->getParameter('fonts_dir');
  146.         $zipDir = $fontDir . 'zip';
  147.         $tmpDir = $fontDir . 'tmp';
  148.         $fileDir = $fontDir . 'fonts' . DIRECTORY_SEPARATOR . $fonts->getBezeichnung();
  149.         if (is_dir($zipDir)) {
  150.             $helper->recursive_destroy_dir($zipDir);
  151.         }
  152.         try {
  153.             $helper->make_is_dir($tmpDir);
  154.         } catch (Exception $e) {
  155.             dd($e->getMessage());
  156.         }
  157.         try {
  158.             $helper->make_is_dir($zipDir);
  159.         } catch (Exception $e) {
  160.             dd($e->getMessage());
  161.         }
  162.         try {
  163.             $helper->recursive_copy($fileDir, $tmpDir . DIRECTORY_SEPARATOR . $fonts->getBezeichnung());
  164.         } catch (Exception $e) {
  165.             dd($e->getMessage());
  166.         }
  168.         $srcCss = $fontDir . 'fonts' . DIRECTORY_SEPARATOR . $fonts->getBezeichnung() . '.css';
  169.         $destCss = $tmpDir . DIRECTORY_SEPARATOR . 'stylesheet.css';
  170.         try {
  171.             $helper->move_file($srcCss, $destCss);
  172.         } catch (Exception $e) {
  173.             dd($e->getMessage());
  174.         }
  175.         $zipFile = $zipDir . DIRECTORY_SEPARATOR . $fonts->getBezeichnung() . '.zip';
  176.         $za = new FlxZip;
  177.         $res = $za->open($zipFile, ZipArchive::CREATE);
  178.         if ($res === true) {
  179.             $za->addDir($tmpDir, '');
  180.             $za->close();
  181.         }
  182.         $helper->recursive_destroy_dir($tmpDir);
  183.         if (is_file($zipFile)) {
  184.             $response = new BinaryFileResponse($zipFile);
  185.             $response->setContentDisposition(
  186.                 ResponseHeaderBag::DISPOSITION_ATTACHMENT,
  187.                 $fonts->getBezeichnung() . '.zip'
  188.             );
  189.             return $response;
  190.         }
  191.     }
  193.     #[Route('/api/get-client', name: 'app_get_client')]
  194.     #[IsGranted('ROLE_OAUTH2_BASIC')]
  195.     public function api_get_client(Request $request): Response
  196.     {
  198.         $callValidate = $this->validate_client($request);
  199.         if (!$callValidate['status']) {
  200.             return $this->json([
  201.                 'error' => $callValidate['msg'],
  202.                 'error_description' => 'Client authentication failed',
  203.                 'message' => 'Client authentication failed'
  204.             ], 403);
  205.         }
  206.         $client = $callValidate['client'];
  207.         $valUser = $callValidate['user'];
  208.         $loggedInEmail = '';
  209.         /** @var User $user */
  210.         if ($this->getUser() !== null) {
  211.             $user = $this->getUser();
  212.             if ($user) {
  213.                 if ($user->getRoles()) {
  214.                     $loggedInEmail = $user->getEmail();
  215.                 }
  216.             }
  217.         }
  218.         //$lizenz = $this->em->getRepository(ProductLicense::class)->get_lizenz($valUser->getId(), $callValidate['redirect_uri']);
  219.         $client = $this->em->getRepository(Client::class)->find($request->get('client_id'));
  221.         if (!in_array($callValidate['redirect_uri'], $client->getRedirectUris())) {
  222.             return $this->json([
  223.                 'error' => $callValidate['msg'],
  224.                 'error_description' => 'Client authentication failed',
  225.                 'message' => 'Client authentication failed (URL)'
  226.             ], 403);
  227.         }
  228.         $lizenz = $this->em->getRepository(ProductLicense::class)->get_lizenz_not_check_uri($valUser->getId());
  229.         //dd($lizenz);
  230.         // $lizenz = $this->em->getRepository(ProductLicense::class)->get_others_uri_lizenz($valUser->getId());
  231.         if (!$lizenz->status) {
  232.             return $this->json([
  233.                 'error' => 'error',
  234.                 'error_description' => 'Client authentication failed',
  235.                 'message' => 'Client authentication failed'
  236.             ], 403);
  237.         }
  239.         $lizenzData = $lizenz->record;
  240.         $lizenzDaten = [];
  241.         foreach ($lizenzData as $tmp) {
  242.             if (!$tmp['activatedAt']) {
  243.                 $activatedAt = new DateTimeImmutable();
  244.                 $activatedAtLizenz = $this->em->getRepository(ProductLicense::class)->find($tmp['id']);
  245.                 $activatedAtLizenz->setActivatedAt($activatedAt);
  246.                 $this->em->persist($activatedAtLizenz);
  247.                 $this->em->flush();
  248.             }
  249.             $produkt = $this->em->getRepository(Product::class)->find($tmp['product_id']);
  250.             unset($tmp['upload_token']);
  251.             $tmp['version'] = $produkt->getVersion();
  252.             $tmp['description'] = $produkt->getBeschreibung();
  253.             $tmp['redirect_uri'] = $callValidate['redirect_uri'];
  254.             $lizenzDaten[] = $tmp;
  255.         }
  256.         $lsP = [];
  257.         $licenseProducts = $this->em->getRepository(Product::class)->findBy(['is_license' => true, 'is_show_api' => true]);
  258.         if ($licenseProducts) {
  259.             foreach ($licenseProducts as $tmp) {
  260.                 $s = $this->get_product_type($tmp->getType());
  261.                 $item = [
  262.                     'basename' => $tmp->getSlug(),
  263.                     'bezeichnung' => $tmp->getBezeichnung(),
  264.                     'type' => $tmp->getType(),
  265.                     'raw_type' => $s['type']
  266.                 ];
  267.                 $lsP[] = $item;
  268.             }
  269.         }
  271.         return $this->json([
  272.             'email' => $client->getName(),
  273.             'logged_in_email' => $loggedInEmail,
  274.             'vorname' => $valUser->getUserdetails()->getFirstName(),
  275.             'nachname' => $valUser->getUserdetails()->getLastName(),
  276.             'lizenz_data' => $lizenzDaten,
  277.             'lizenz_products' => $lsP,
  278.             'cronjob' => $valUser->getUserdetails()->getCronjob(),
  279.             'scope' => explode(',', $callValidate['scopes']),
  280.         ], 200);
  281.     }
  283.     #[Route('/api/{product_license}/wp-cron', name: 'app_wp_cron_check')]
  284.     public function wp_cron_check(Request $request): Response
  285.     {
  286.         $product_license = $request->get('product_license');
  287.         $redirectUri = $request->query->get('redirect_uri');
  288.         $redirect_uri = filter_var($redirectUri, FILTER_VALIDATE_URL);
  290.         if (!$product_license || !$redirect_uri) {
  291.             return $this->json([
  292.                 'error' => 'not-found',
  293.                 'error_description' => 'Product not found',
  294.                 'message' => 'Product not found',
  295.             ], 401);
  296.         }
  298.         $productLicense = $this->em->getRepository(ProductLicense::class)->get_license_cron($product_license);
  300.         if (!$productLicense) {
  301.             return $this->json([
  302.                 'error' => 'not-found',
  303.                 'error_description' => 'Product not found',
  304.                 'message' => 'Product not found or not active',
  305.                 'delete_file' => 1
  306.             ], 401);
  307.         }
  308.         if (!$productLicense['aktiv']) {
  309.             return $this->json([
  310.                 'error' => 'not-active (' . __LINE__ . ')',
  311.                 'error_description' => 'License not active',
  312.                 'message' => 'License not active',
  313.                 'delete_file' => 0
  314.             ], 401);
  315.         }
  317.         if (!in_array($redirect_uri, $productLicense['redirectUris'])) {
  318.             return $this->json([
  319.                 'error' => 'error',
  320.                 'error_description' => 'Client authentication failed',
  321.                 'message' => 'Client authentication failed (URL)'
  322.             ], 403);
  323.         }
  326.         $dateTime = date('Y-m-d H:i:s', strtotime($productLicense['activatedAt']->format('Y-m-d H:i:s')));
  327.         $lizenz = $this->em->getRepository(Licences::class)->find($productLicense['licenseId']);
  329.         $days = $lizenz->getTimeLimit();
  330.         $rest = strtotime("$dateTime +$days days");
  331.         if ($lizenz->getTimeLimit() && $rest - time() <= 0) {
  332.             return $this->json([
  333.                 'error' => 'not-active (' . __LINE__ . ')',
  334.                 'error_description' => 'License not active',
  335.                 'message' => 'License not active',
  336.                 'delete_file' => 0
  337.             ], 401);
  338.         }
  339.         return $this->json([
  340.             'license' => $product_license,
  341.         ], 200);
  342.     }
  344.     #[Route('/api/{product_license}/token', name: 'app_get_download_code')]
  345.     public function get_download_code(Request $request): RedirectResponse
  346.     {
  347.         $redirect = urldecode($request->get('redirect'));
  349.         $license = $this->em->getRepository(ProductLicense::class)->get_license_by_product_license(['product_license' => $request->get('product_license')]);
  351.         if ($license && $license['redirectUris'] && in_array($redirect, $license['redirectUris'])) {
  352.             return $this->redirect($redirect . '?upload_code=' . $license['upload_token'] . '&type=' . $license['product_type'] . '&slug=' . $license['product_slug']);
  353.         }
  354.         return $this->redirect($redirect . '?error=URL nicht gefunden.');
  355.     }
  357.     #[Route('/api/download-free', name: 'app_download_free')]
  358.     #[IsGranted('ROLE_OAUTH2_PRODUCT')]
  359.     public function api_download_free(Request $request): Response
  360.     {
  361.         $body = json_decode($request->getContent(), true);
  362.         $product = $this->em->getRepository(Product::class)->find($body['product_id']);
  364.         if (!$product) {
  365.             return $this->json([
  366.                 'error' => 'not found db',
  367.                 'error_description' => 'Product not found',
  368.                 'message' => 'Product not found',
  369.             ], 401);
  370.         }
  372.         if (!in_array($product->getType(), $this->free_products)) {
  373.             return $this->json([
  374.                 'error' => 'not free',
  375.                 'error_description' => 'No free product',
  376.                 'message' => 'No free product'
  377.             ], 403);
  378.         }
  380.         return $this->json([
  381.             'slug' => $product->getSlug(),
  382.             'type' => $product->getType(),
  383.             'download' => '/api/' . $product->getId() . '/download'
  384.         ], 200);
  385.     }
  388.     #[Route('/api/{slug}/{type}/update-options', name: '_api_product_update_options')]
  389.     public function update_options(Request $request): Response
  390.     {
  391.         $slug = $request->get('slug');
  392.         $type = $request->get('type');
  393.         $product = $this->em->getRepository(Product::class)->findOneBy(['slug' => $slug]);
  394.         if (!$product) {
  395.             return $this->json([
  396.                 'error' => 'not found db',
  397.                 'error_description' => 'Product not found',
  398.                 'message' => 'Product not found',
  399.             ], 401);
  400.         }
  401.         if ($product->getUpdateChecker()) {
  402.             $update = json_decode($product->getUpdateChecker()->getUpdateData(), true);
  403.             $gitData = json_decode($product->getUpdateChecker()->getGitData(), true);
  404.         } else {
  405.             return $this->json([
  406.                 'error' => 'not found db',
  407.                 'error_description' => 'Product not found',
  408.                 'message' => 'Product not found',
  409.             ], 401);
  410.         }
  411.         $selfUrl = $request->getSchemeAndHttpHost();
  412.         if ($type == 'conf') {
  413.             return $this->json([
  414.                 'is_git' => $product->isIsGit(),
  415.                 'is_aktive' => $product->getUpdateChecker()->isAktive(),
  416.                 'self' => $selfUrl,
  417.                 'git_data' => $gitData,
  418.                 'update_url' => $selfUrl . '/api/' . $slug . '/update/update-options'
  420.             ], 200);
  421.         }
  423.         if ($product->getUpdateChecker()->getType() == 'plugin') {
  424.             if (!$product->getUpdateChecker()->isRatingAktiv()) {
  425.                 unset($update['rating']);
  426.                 unset($update['num_ratings']);
  427.                 unset($update['downloaded']);
  428.                 unset($update['active_installs']);
  429.             }
  430.             if (!$product->getUpdateChecker()->isLanguageAktiv()) {
  431.                 unset($update['translations']);
  432.             }
  433.         }
  434.         return $this->json(
  435.             $update
  436.             , 200);
  437.     }
  439.     /**
  440.      * @param Product $product
  441.      * @return BinaryFileResponse|void
  442.      */
  443.     #[IsGranted('ROLE_OAUTH2_PRODUCT')]
  444.     #[Route('/api/{id}/download', name: '_download_api_product')]
  445.     public function download_product(Product $product)
  446.     {
  447.         $file = $this->getParameter('product_dir') . '/' . $product->getSlug() . '/' . $product->getSlug() . '.zip';
  448.         if (is_file($file)) {
  449.             $response = new BinaryFileResponse($file);
  450.             $response->setContentDisposition(
  451.                 ResponseHeaderBag::DISPOSITION_ATTACHMENT,
  452.                 $product->getSlug() . '.zip'
  453.             );
  454.             return $response;
  455.         }
  456.     }
  458.     /**
  459.      * @param Request $request
  460.      * @return BinaryFileResponse|JsonResponse
  461.      */
  462.     #[IsGranted('ROLE_OAUTH2_PRODUCT')]
  463.     #[Route('/api/{upload_token}/lizenz-product-download', name: '_download_api_lizenz_product')]
  464.     public function download_lizenz_product(Request $request): BinaryFileResponse|JsonResponse
  465.     {
  467.         /* if(!$this->isGranted('ROLE_OAUTH2_PRODUCT')) {
  468.              return $this->json([
  469.                  'error' => 'ungültiger access token',
  470.                  'error_description' => 'ungültiger access token',
  471.                  'message' => 'ungültiger access token',
  472.              ], 403);
  473.          }*/
  474.         $productLicense = $this->em->getRepository(ProductLicense::class)->findOneBy(['upload_token' => $request->get('upload_token')]);
  475.         if (!$productLicense) {
  476.             return $this->json([
  477.                 'error' => 'not found product license',
  478.                 'error_description' => 'Product not found',
  479.                 'message' => 'Product not found',
  480.             ], 401);
  481.         }
  482.         // dd($productLicense, $request->get('upload_token'));
  483.         //ProductLicense $productLicense
  484.         $product = $this->em->getRepository(Product::class)->find($productLicense->getProductId());
  485.         if (!$product) {
  486.             return $this->json([
  487.                 'error' => 'not found product',
  488.                 'error_description' => 'Product not found',
  489.                 'message' => 'Product not found',
  490.             ], 401);
  491.         }
  492.         $file = $this->getParameter('product_dir') . '/' . $product->getSlug() . '/' . $product->getSlug() . '.zip';
  494.         if (is_file($file)) {
  495.             $helper = Helper::instance();
  496.             $newToken = $helper->generate_callback_pw(200, 0, 100);
  497.             $productLicense->setUploadToken($newToken);
  498.             $productLicense->setAktiv(true);
  499.             $this->em->persist($productLicense);
  500.             $this->em->flush();
  501.             $response = new BinaryFileResponse($file);
  502.             $response->setContentDisposition(
  503.                 ResponseHeaderBag::DISPOSITION_ATTACHMENT,
  504.                 $product->getSlug() . '.zip'
  505.             );
  506.             return $response;
  507.         }
  509.         return $this->json([
  510.             'error' => 'not found file',
  511.             'error_description' => 'Product not found',
  512.             'message' => 'Product not found',
  513.         ], 401);
  514.     }
  517.     /**
  518.      * @param Request $request
  519.      * @return BinaryFileResponse|Response
  520.      */
  521.     #[Route('/api/{product_license}/aktivierungs-file', name: '_download_api_lizenz_file')]
  522.     #[IsGranted('ROLE_OAUTH2_PRODUCT')]
  523.     public function aktivierungs_file_data(Request $request): BinaryFileResponse|Response
  524.     {
  525.         $productLicense = $this->em->getRepository(ProductLicense::class)->findOneBy(['product_license' => $request->get('product_license')]);
  526.         //ProductLicense $productLicense
  527.         $produkt = $this->em->getRepository(Product::class)->find($productLicense->getProductId());
  528.         $version = str_replace(['v'], '-', $produkt->getVersion());
  529.         $filePath = $this->getParameter('product_dir') . '/' . $produkt->getSlug() . '/' . $produkt->getSlug() . $version . '/' . $produkt->getAktivierungsPath();
  530.         if (is_file($filePath) && $productLicense->isAktiv()) {
  531.             $response = new BinaryFileResponse($filePath);
  532.             $response->setContentDisposition(
  533.                 ResponseHeaderBag::DISPOSITION_ATTACHMENT,
  534.                 basename($filePath)
  535.             );
  536.             return $response;
  537.         }
  538.         return $this->json([
  539.             'error' => 'not found',
  540.             'error_description' => 'Not found product',
  541.             'message' => 'Not found product',
  542.             'file' => $filePath
  543.         ], 403);
  544.     }
  547.     #[Route('/api/remove-consent', name: 'app_remove_consent')]
  548.     #[IsGranted('ROLE_OAUTH2_BASIC')]
  549.     public function remove_consent(Request $request): Response
  550.     {
  551.         $callValidate = $this->validate_client($request);
  552.         if (!$callValidate['status']) {
  553.             return $this->json([
  554.                 'error' => $callValidate['msg'],
  555.                 'error_description' => 'Client authentication failed',
  556.                 'message' => 'Client authentication failed'
  557.             ], 403);
  558.         }
  560.         $client = $callValidate['client'];
  561.         $valUser = $callValidate['user'];
  562.         $consent = $this->em->getRepository(OAuth2UserConsent::class)->findOneBy(['user' => $valUser]);
  563.         if (!$consent) {
  564.             return $this->json([
  565.                 'error' => $callValidate['msg'],
  566.                 'error_description' => 'Not found',
  567.                 'message' => 'Consent not found'
  568.             ], 403);
  569.         }
  570.         $this->em->remove($consent);
  571.         $this->em->flush();
  573.         return $this->json([
  574.             'email' => $client->getName(),
  575.             'vorname' => $valUser->getUserdetails()->getFirstName(),
  576.             'nachname' => $valUser->getUserdetails()->getLastName(),
  577.             'scope' => explode(',', $callValidate['scopes']),
  578.         ], 200);
  580.     }
  582.     private function validate_client($request): array
  583.     {
  584.         $client = $this->em->getRepository(Client::class)->findOneBy(['identifier' => $request->request->get('client_id')]);
  585.         $user = $this->em->getRepository(User::class)->findOneBy(['email' => $client->getName()]);
  586.         $scopes = implode(',', $client->getScopes());
  587.         $user_active = $user->getUserdetails()->isAktiv();
  588.         if (!$client->isActive() || !$user_active) {
  589.             return [
  590.                 'status' => false,
  591.                 'msg' => 'User not active',
  592.             ];
  593.         }
  595.         $urlError = false;
  596.         $redirect_uri = filter_var($request->request->get('redirect_uri'), FILTER_VALIDATE_URL);
  597.         if (!$redirect_uri) {
  598.             $urlError = true;
  599.         }
  601.         $apiRedirect = $client->getRedirectUris();
  602.         $apiRedirect = implode(',', $apiRedirect);
  603.         $apiRedirect = explode(',', $apiRedirect);
  604.         if (!in_array($redirect_uri, $apiRedirect)) {
  605.             $urlError = true;
  606.         }
  607.         if ($urlError) {
  608.             return [
  609.                 'status' => false,
  610.                 'msg' => sprintf('User not active for this URL: %s', $redirect_uri),
  611.             ];
  612.         }
  614.         return [
  615.             'status' => true,
  616.             'client' => $client,
  617.             'user' => $user,
  618.             'scopes' => $scopes,
  619.             'redirect_uri' => $redirect_uri
  620.         ];
  621.     }
  622. }