src/Controller/ApiPluginController.php line 105

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\AuctionAccount;
  6. use App\Entity\AuctionBid;
  7. use App\Entity\PluginEventLog;
  8. use App\Entity\PluginLotData;
  9. use App\Entity\PluginPing;
  10. use App\Entity\PluginToken;
  11. use App\Entity\PluginUser;
  12. use App\Entity\PluginUserAuctionAccountAssigment;
  13. use App\Entity\ProxyAccount;
  14. use App\Exception\Plugin\BadRequestException;
  15. use App\Exception\Plugin\InvalidTokenException;
  16. use App\Repository\AccountCodeRepository;
  17. use App\Form\PluginUserType;
  18. use App\Repository\PluginTokenRepository;
  19. use App\Repository\PluginUserRepository;
  20. use App\Service\Utils\CommonUtils;
  21. use App\Service\Utils\FileUploader;
  22. use Sensio\Bundle\FrameworkExtraBundle\Configuration\IsGranted;
  23. use Doctrine\ORM\EntityManagerInterface;
  24. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  25. use Symfony\Component\HttpFoundation\File\UploadedFile;
  26. use Symfony\Component\HttpFoundation\JsonResponse;
  27. use Symfony\Component\HttpFoundation\Request;
  28. use Symfony\Component\HttpFoundation\Response;
  29. use Symfony\Component\Routing\Annotation\Route;
  30. use Symfony\Contracts\Translation\TranslatorInterface;
  32. /**
  33.  * @Route("/api_plugin", name="api_plugin_")
  34.  */
  35. class ApiPluginController extends AbstractController
  36. {
  37.     const STATIC_VPN_CONFIG = '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';
  38.     const HEADERS = 'Access-Control-Allow-Origin: *';
  39.     const ALLOWED_DOMAINS = [
  40.         'https://copart.com',
  41.         'https://www.copart.com',
  42.         ];
  44.     /**
  45.      * @var FileUploader
  46.      */
  47.     private $fileUploader;
  49.     /**
  50.      * @var TranslatorInterface
  51.      */
  52.     private $translator;
  54.     public function __construct(TranslatorInterface $translator, FileUploader $fileUploader)
  55.     {
  56.         $this->translator = $translator;
  57.         $this->fileUploader = $fileUploader;
  58.     }
  60.     /**
  61.      * @Route("/headers_sh", name="headers_show", methods={"GET, POST"})
  62.      * @param Request $request
  63.      * @return Response
  64.      */
  65.     public function headers_show(Request $request): Response
  66.     {
  67.         //$headers = $request->headers->all();
  68.         //dd($headers);
  69.         return new JsonResponse([], 200);
  70.     }
  72.     /**
  73.      * @param PluginToken $token
  74.      * @return void
  75.      */
  76.     private function disableToken(PluginToken $token)
  77.     {
  78.         $token
  79.             ->setStatus('off')
  80.             ->setDisabledAt(new \DateTime('now'));
  82.         $em = $this->getDoctrine()->getManager();
  83.         $em->persist($token);
  84.         $em->flush();
  85.     }
  87.     /**
  88.      * @Route("/user_auth", name="user_auth", methods={"POST"})
  89.      * @return Response
  90.      */
  91.     public function pluginUserAuth(PluginTokenRepository $pluginTokenRepository, PluginUserRepository $pluginUserRepository, Request $request): Response
  92.     {
  93.         $proxy = [];
  94.         $parameters = json_decode($request->getContent(), true);
  95.         if (empty($parameters) || empty($parameters['login']) || empty($parameters['password'])) {
  96.             header(self::HEADERS);
  97.             return new JsonResponse('Bad Request', 400);
  98.         }
  99.         if (empty($parameters['pv'])) {
  100.             header(self::HEADERS);
  101.             return new JsonResponse('Unknown Application', 400);
  102.         }
  104.         $pluginUser = $pluginUserRepository->findOneBy(['login' => $parameters['login'],'deleted' => 0]);
  105.         $entityManager = $this->getDoctrine()->getManager();
  107.         if (!$pluginUser) {
  108.             header(self::HEADERS);
  109.             return new JsonResponse('Invalid login', 401);
  110.         } elseif ($parameters['password'] != $pluginUser->getPassword()) {
  111.             header(self::HEADERS);
  112.             return new JsonResponse('Invalid password', 401);
  113.         }
  115.         if (!$pluginUser->getOwner()->getEnablePlugin()){
  116.             header(self::HEADERS);
  117.             return new JsonResponse('Plugin disabled', 401);
  118.         }
  119.         if(!in_array($pluginUser->getOwner()->getId(), [1, 54, 10] )) { //developer, Katerina, Nikita
  120.             if (!preg_match('/^.*((app)|(android)|(ios)|(windows)|(mac)).*/i', $parameters['pv'], $matches) || !$matches) {
  121.                 header(self::HEADERS);
  122.                 return new JsonResponse('Access Denied', 403);
  123.             }
  124.         }
  126. //        $onPluginTokens = $pluginTokenRepository->findBy(['plugin_user' => $pluginUser, 'status' => 'on']);
  127. //        if ($onPluginTokens) {
  128. //            foreach ($onPluginTokens as $onPluginToken) {
  129. //                $onPluginToken
  130. //                    ->setStatus('off')
  131. //                    ->setDisabledAt(new \DateTime('now'));
  132. //                $entityManager->persist($onPluginToken);
  133. //                $entityManager->flush();
  134. //            }
  135. //        }
  137.         $is_token = true;
  138.         while ($is_token) {
  139.             $token = substr(hash('sha256', mt_rand()), 0, 40);
  140.             $is_token = $pluginTokenRepository->findOneBy(['token' => $token]);
  141.         }
  143.         $pluginToken = new PluginToken();
  144.         $pluginToken
  145.             ->setToken($token)
  146.             ->setPluginUser($pluginUser);
  147.         $entityManager->persist($pluginToken);
  148.         $entityManager->flush();
  150.         $customer = $pluginUser->getCustomer();
  151.         $owner = $pluginUser->getOwner();
  153.         if ($customer) {
  154.             $id = $customer->getId();
  155.             $name = $customer->getUsername();
  156.         } else {
  157.             $id = $owner->getId();
  158.             $name = $owner->getUsername();
  159.         }
  161.         if(isset($parameters['auction']) && $parameters['auction'] == 'manheim') {
  162.             $AuctionAccounts = $pluginToken->getPluginUser()->getOnlyManheimAccounts();
  163.             $count = count($AuctionAccounts);
  165.             if ($count < 1) {
  166.                 header(self::HEADERS);
  167.                 return new JsonResponse('Invalid Manheim accounts', 401);
  168.             }
  170.             $em = $this->getDoctrine()->getManager();
  171.             $proxyAccount = $em->getRepository(ProxyAccount::class)->findLastUsedManheimProxy();
  172.             // $key = random_int(0, $count - 1);
  173.             // $auctionAccount = $AuctionAccounts[$key];
  174. //        $login = $auctionAccount->getLogin();
  175. //        $password = $auctionAccount->getPassword();
  176.             // $proxyAccount = $auctionAccount->getProxyAccount();
  178.             if ($proxyAccount) {
  179.                 $proxy = [
  180.                     'proxy' => [
  181.                         'host' => $proxyAccount->getProxyHost() ?? '',
  182.                         'port' => $proxyAccount->getProxyPort() ?? '',
  183.                         'username' => $proxyAccount->getProxyUsername() ?? '',
  184.                         'password' => $proxyAccount->getProxyPassword() ?? '',
  185.                     ]
  186.                 ];
  188.                 $proxyAccount->setLastUsedAt(new \DateTime('now'));
  189.                 $em->persist($proxyAccount);
  190.                 $em->flush();
  191.             }
  192.         }
  194.         $data = [
  195.             'id' => $pluginUser->getId(),
  196.             'name' => $name,
  197.             'token' => $token,
  198.             'allowLogging' => true,
  199.         ];
  201.         if(!empty($proxy)) {
  202.             $data = array_merge($data, $proxy);
  203.         }
  204.         header(self::HEADERS);
  205.         return new JsonResponse($data, 200);
  206.     }
  208.     /**
  209.      * @param EntityManagerInterface $em
  210.      * @param Request $request
  211.      * @return PluginToken
  212.      * @throws BadRequestException
  213.      * @throws InvalidTokenException
  214.      */
  215.     private function _authUserByToken(EntityManagerInterface $em, Request $request): PluginToken
  216.     {
  217.         $pluginTokenRepository = $em->getRepository(PluginToken::class);
  218.         $parameters = json_decode($request->getContent(), true);
  219.         if(!empty($parameters['user'])) { // if request is from universal APP
  220.             $parameters = $parameters['user'];
  221.         }
  222.         if (empty($parameters) || empty($parameters['id']) || empty($parameters['name']) || empty($parameters['token']) || empty($parameters['pv'])) {
  223.             throw new BadRequestException();
  224.         }
  225.         $pluginToken = $pluginTokenRepository->findOneBy(['token' => $parameters['token'], 'status' => 'on']);
  227.         if (!$pluginToken instanceof PluginToken) {
  228.             throw new InvalidTokenException();
  229.         }
  231.         if(!$pluginToken->getPluginUser()->getOwner()->getEnablePlugin()){
  232.             $this->disableToken($pluginToken);
  233.             throw new InvalidTokenException();
  234.         }
  236.         if($pluginToken->getPluginUser()->getDeleted()){
  237.             $this->disableToken($pluginToken);
  238.             throw new InvalidTokenException();
  239.         }
  240.         if(!in_array($pluginToken->getPluginUser()->getOwner()->getId(), [1, 54, 10] )) { //developer, Katerina, Nikita
  241.             if (!preg_match('/^.*((app)|(android)|(ios)|(windows)|(mac)).*/i', $parameters['pv'], $matches) || !$matches) {
  242.                 $this->disableToken($pluginToken);
  243.                 throw new InvalidTokenException();
  244.             }
  245.         }
  247.         return $pluginToken;
  248.     }
  250.     /**
  251.      * @Route("/get_copart_account", name="get_copart_account", methods={"POST"})
  252.      * @param Request $request
  253.      * @param EntityManagerInterface $em
  254.      * @return Response
  255.      */
  256.     public function getCopartAccount(Request $request, EntityManagerInterface $em): Response
  257.     {
  258.         try {
  259.             $pluginToken = $this->_authUserByToken($em, $request);
  260.         } catch (BadRequestException $e) {
  261.             header(self::HEADERS);
  262.             return new JsonResponse('Bad Request', 400);
  263.         } catch (InvalidTokenException $e) {
  264.             header(self::HEADERS);
  265.             return new JsonResponse('Invalid token', 401);
  266.         }
  267.         $parameters = json_decode($request->getContent(), true);
  268.         $plugin_version = $parameters['pv'] ?? '';
  269.         $allValue = $parameters['all'] ?? false;
  270.         $all = is_bool($allValue)
  271.             ? $allValue
  272.             : (is_int($allValue)
  273.                 ? $allValue === 1
  274.                 : (is_string($allValue) && in_array(strtolower(trim($allValue)), ['1', 'true', 'yes'], true)));
  275.         if (empty($plugin_version)) {
  276.             header(self::HEADERS);
  277.             return new JsonResponse('Invalid pv', 400);
  278.         }
  279.         $ip = CommonUtils::getClientIP($request);
  281.         $pluginUser = $pluginToken->getPluginUser();
  282.         $AuctionAccounts = $pluginUser->getOnlyCopartAccounts();
  284.         if (count($AuctionAccounts) < 1) {
  285.             header(self::HEADERS);
  286.             return new JsonResponse('Invalid Copart accounts', 401);
  287.         }
  289.         $accountFinancesAccesses = $pluginUser->getAccountsFinancesAccessMap();
  290.         $assigmentRepository = $em->getRepository(PluginUserAuctionAccountAssigment::class);
  292.         if ($all) {
  293.             $allCopartAccounts = [];
  294.             foreach ($AuctionAccounts as $auctionAccount) {
  295.                 $canManagePayments = $accountFinancesAccesses[$auctionAccount->getId()] ?? false;
  296.                 $accountData = [
  297.                     'id' => $auctionAccount->getId(),
  298.                     'auction_account_id' => $auctionAccount->getId(),
  299.                     'account_name' => $auctionAccount->getCommonName() ?? '',
  300.                     'login' => $auctionAccount->getLogin() ?? '',
  301.                     'password' => $auctionAccount->getPassword() ?? '',
  302.                     'can_manage_payments' => $canManagePayments,
  303.                 ];
  304.                 $proxyAccount = $auctionAccount->getProxyAccount();
  305.                 $proxy = [];
  306.                 if ($proxyAccount) {
  307.                     $proxy = [
  308.                         'proxy' => [
  309.                             'host' => $proxyAccount->getProxyHost() ?? '',
  310.                             'port' => $proxyAccount->getProxyPort() ?? '',
  311.                             'username' => $proxyAccount->getProxyUsername() ?? '',
  312.                             'password' => $proxyAccount->getProxyPassword() ?? '',
  313.                         ]
  314.                     ];
  315.                 }
  316.                 if (!empty($proxy)) {
  317.                     $accountData['proxy'] = $proxy['proxy'];
  318.                 }
  319.                 $allCopartAccounts[] = $accountData;
  320.             }
  322.             header(self::HEADERS);
  323.             return new JsonResponse(['copart_accounts' => $allCopartAccounts], 200);
  324.         }
  326.         $auctionAccount = $assigmentRepository->selectAuctionAccountForAssigment($AuctionAccounts, $accountFinancesAccesses);
  327.         $pluginAuctionAssignment = $assigmentRepository->createAuctionAssignment($auctionAccount, $pluginToken, $plugin_version, $ip);
  329.         $canManagePayments = $accountFinancesAccesses[$auctionAccount->getId()] ?? false;
  331.         $proxyAccount = $auctionAccount->getProxyAccount();
  332.         $proxy = [];
  333.         if ($proxyAccount) {
  334.             $proxy = [
  335.                 'proxy' => [
  336.                     'host' => $proxyAccount->getProxyHost() ?? '',
  337.                     'port' => $proxyAccount->getProxyPort() ?? '',
  338.                     'username' => $proxyAccount->getProxyUsername() ?? '',
  339.                     'password' => $proxyAccount->getProxyPassword() ?? '',
  340.                 ]
  341.             ];
  342.         }
  345.         $data = [
  346.             'copart' => [
  347.                 'id' => $pluginAuctionAssignment->getAuctionAccount()->getId(),
  348.                 'account_name' => $pluginAuctionAssignment->getAuctionAccount()->getCommonName() ?? '',
  349.                 'login' => $pluginAuctionAssignment->getAuctionAccount()->getLogin() ?? '',
  350.                 'password' => $pluginAuctionAssignment->getAuctionAccount()->getPassword() ?? '',
  351.             ],
  352.             'assigment_id' => $pluginAuctionAssignment->getId(),
  353.             'can_manage_payments' => $canManagePayments,
  354.         ];
  355.         header(self::HEADERS);
  356.         return new JsonResponse(array_merge($data, $proxy), 200);
  357.     }
  360.     /**
  361.      * @Route("/bid_clicked", name="bid_clicked", methods={"POST"})
  362.      * @param Request $request
  363.      * @param EntityManagerInterface $em
  364.      * @return Response
  365.      */
  366.     public function bidClicked(Request $request, EntityManagerInterface $em): Response
  367.     {
  368.         try {
  369.             $pluginToken = $this->_authUserByToken($em, $request);
  370.         } catch (BadRequestException $e) {
  371.             header(self::HEADERS);
  372.             return new JsonResponse('Bad Request', 400);
  373.         } catch (InvalidTokenException $e) {
  374.             header(self::HEADERS);
  375.             return new JsonResponse('Invalid token', 401);
  376.         }
  377.         $parameters = json_decode($request->getContent(), true);
  378.         $lot = $parameters['lot'] ?? '';
  379.         $bid = $parameters['bid'] ?? false;
  380.         $auctionLocation = mb_substr(trim($parameters['auction_location'] ?? ''), 0, 60);
  381.         $bid_type = strtolower($parameters['bid_type']) ?? '';
  382.         $session_url = $parameters['session_url'] ?? '';
  383.         $window_host = $parameters['window_host'] ?? '';
  384.         $loggedCopart =
  385.             $parameters['loggedCopart'] ??
  386.             $parameters['loggedIaai'] ??
  387.             $parameters['loggedManheim'] ??
  388.             $parameters['loggedBringatrailer'] ??
  389.             $parameters['loggedCars_and_bids'] ??
  390.             $parameters['loggedCars'] ??
  391.             $parameters['loggedCargurus'] ?? false;
  393.         if (empty($lot)) {
  394.             header(self::HEADERS);
  395.             return new JsonResponse('Invalid lot', 400);
  396.         }
  398.         if ($bid === false) {
  399.             header(self::HEADERS);
  400.             return new JsonResponse('Invalid bid', 400);
  401.         }
  403.         if(empty($bid_type) || !in_array($bid_type, AuctionBid::TYPES)){
  404.             header(self::HEADERS);
  405.             return new JsonResponse('Invalid bid_type', 400);
  406.         }
  408.         if (empty($parameters['assigment_id'])) {
  409.             header(self::HEADERS);
  410.             return new JsonResponse('Invalid assigment', 406);
  411.         }
  412.         $assignedAuctionAccount = $em->getRepository(PluginUserAuctionAccountAssigment::class)->find((int)$parameters['assigment_id']);
  413.         if (!$assignedAuctionAccount instanceof PluginUserAuctionAccountAssigment) {
  414.             header(self::HEADERS);
  415.             return new JsonResponse('Invalid assigment', 406);
  416.         }
  417.         /******* check iaai country *********/
  418.         /*$auctionAccount = $assignedAuctionAccount->getAuctionAccount();
  419.         if (strtolower($auctionAccount->getAuctionName()) === 'iaai') {
  420.             if (!empty($window_host)) {
  421.                 if (($window_host === 'www.iaai.com') && ($auctionAccount->getCountry() === 'usa')) {
  422.                     true;
  423.                 } elseif (($window_host === 'ca.iaai.com') && ($auctionAccount->getCountry() === 'canada')) {
  424.                     true;
  425.                 } else {
  426.                     header(self::HEADERS);
  427.                     return new JsonResponse('Invalid country in window_host', 406);
  428.                 }
  429.             } else {
  430.                 header(self::HEADERS);
  431.                 return new JsonResponse('Invalid window_host', 406);
  432.             }
  433.         }*/
  434.         /******* end *********/
  435.         $auctionBid = (new AuctionBid())
  436.             ->setCreatedAt(new \DateTime('now'))
  437.             ->setAssignation($assignedAuctionAccount)
  438.             ->setBid((float)$bid)
  439.             ->setLot($lot)
  440.             ->setLoggedCopart((bool)$loggedCopart)
  441.             ->setType($bid_type)
  442.             ->setSessionUrl($session_url)
  443.             ->setAuctionLocation($auctionLocation);
  444.         $em->persist($auctionBid);
  445.         $em->flush();
  446.         header(self::HEADERS);
  447.         return new JsonResponse(['history_id' => $auctionBid->getId()], 200);
  448.     }
  450.     /**
  451.      * @Route("/get_assigment_finances_access", name="assigment_finances_access", methods={"POST"})
  452.      * @param Request $request
  453.      * @param EntityManagerInterface $em
  454.      * @return Response
  455.      */
  456.     public function getAssigmentFinancesAccess(Request $request, EntityManagerInterface $em): Response
  457.     {
  458.         try {
  459.             $pluginToken = $this->_authUserByToken($em, $request);
  460.         } catch (BadRequestException $e) {
  461.             header(self::HEADERS);
  462.             return new JsonResponse('Bad Request', 400);
  463.         } catch (InvalidTokenException $e) {
  464.             header(self::HEADERS);
  465.             return new JsonResponse('Invalid token', 401);
  466.         }
  467.         $parameters = json_decode($request->getContent(), true);
  468.         $assigmentId = $parameters['assigment_id'] ?? null;
  469.         if (empty($assigmentId)) {
  470.             header(self::HEADERS);
  471.             return new JsonResponse('Invalid assigment', 406);
  472.         }
  473.         $pluginUser = $pluginToken->getPluginUser();
  474.         $assignedAuctionAccount = $em->getRepository(PluginUserAuctionAccountAssigment::class)->find((int)$parameters['assigment_id']);
  475.         if (!$assignedAuctionAccount instanceof PluginUserAuctionAccountAssigment
  476.             || $assignedAuctionAccount->getPluginUser()->getId() !== $pluginUser->getId()
  477.         ) {
  478.             header(self::HEADERS);
  479.             return new JsonResponse('Invalid assigment', 406);
  480.         }
  481.         $accountFinancesAccesses = $pluginUser->getAccountsFinancesAccessMap();
  482.         $canManageFinances = $accountFinancesAccesses[$assignedAuctionAccount->getAuctionAccount()->getId()] ?? false;
  484.         header(self::HEADERS);
  485.         return new JsonResponse(['can_manage_finances' => $canManageFinances], 200);
  486.     }
  488.     /**
  489.      * @Route("/ping", name="ping", methods={"POST"})
  490.      * @param Request $request
  491.      * @param EntityManagerInterface $em
  492.      * @return Response
  493.      */
  494.     public function ping(Request $request, EntityManagerInterface $em): Response
  495.     {
  497.         try {
  498.             $pluginToken = $this->_authUserByToken($em, $request);
  499.         } catch (BadRequestException $e) {
  500.             header(self::HEADERS);
  501.             return new JsonResponse('Bad Request', 400);
  502.         } catch (InvalidTokenException $e) {
  503.             header(self::HEADERS);
  504.             return new JsonResponse('Invalid token', 401);
  505.         }
  507.         $parameters = json_decode($request->getContent(), true);
  508.         $assigment_id = $parameters['assigment_id'] ?? '';
  509.         $token = $parameters['token'] ?? '';
  510.         $loggedCopart =
  511.             $parameters['loggedCopart'] ??
  512.             $parameters['loggedIaai'] ??
  513.             $parameters['loggedManheim'] ??
  514.             $parameters['loggedBringatrailer'] ??
  515.             $parameters['loggedCars_and_bids'] ??
  516.             $parameters['loggedCars'] ??
  517.             $parameters['loggedCargurus'] ?? false;
  518.         $loggedPlugin = $parameters['loggedPlugin'] ?? '';
  519. //        $date = $parameters['date'] ?? '';
  521.         if (empty($assigment_id)) {
  522.             header(self::HEADERS);
  523.             return new JsonResponse('Empty assigment_id', 400);
  524.         }
  525.         if (empty($token)) {
  526.             header(self::HEADERS);
  527.             return new JsonResponse('Empty token', 406);
  528.         }
  529. //        if (empty($loggedCopart)) {
  530. //            return new JsonResponse('Empty loggedCopart', 406);
  531. //        }
  532. //        if (empty($loggedPlugin)) {
  533. //            return new JsonResponse('Empty loggedPlugin', 406);
  534. //        }
  535. //        if (empty($date)) {
  536. //            return new JsonResponse('Empty date', 406);
  537. //        }
  539.         $assignedAuctionAccount = $em->getRepository(PluginUserAuctionAccountAssigment::class)->find((int)$assigment_id);
  540.         if (!$assignedAuctionAccount instanceof PluginUserAuctionAccountAssigment) {
  541.             header(self::HEADERS);
  542.             return new JsonResponse('Invalid assigment', 406);
  543.         }
  544.         if($pluginToken->getToken() != $token){
  545.             header(self::HEADERS);
  546.             return new JsonResponse('Invalid token', 406);
  547.         }
  549.         $pluginPing = (new PluginPing())
  550.             ->setAssigment($assignedAuctionAccount)
  551.             ->setToken($pluginToken)
  552.             ->setLoggedCopart((bool)$loggedCopart)
  553.             ->setLoggedPlugin((bool)$loggedPlugin)
  554.             ->setDate( new \DateTime('now'));
  555.         $em->persist($pluginPing);
  556.         $em->flush();
  558.         header(self::HEADERS);
  559.         return new JsonResponse(['status' => 'Ok'], 200);
  560.     }
  562.     /**
  563.      * @Route("/add_event_log", name="add_event_log", methods={"POST"})
  564.      * @param Request $request
  565.      * @param EntityManagerInterface $em
  566.      * @return Response
  567.      */
  568.     public function addEventLog(Request $request, EntityManagerInterface $em): Response
  569.     {
  570.         $parameters = json_decode($request->getContent(), true);
  571.         if (empty($parameters['event'])) {
  572.             header(self::HEADERS);
  573.             return new JsonResponse('Empty event', 400);
  574.         }
  575.         if (empty($parameters['eventData']) || !is_array($parameters['eventData'])) {
  576.             header(self::HEADERS);
  577.             return new JsonResponse('Bad data', 400);
  578.         }
  580.         $ip = CommonUtils::getClientIP($request);
  581.         $pluginEventLog = (new PluginEventLog())
  582.             ->setIp($ip)
  583.             ->setCreatedAt(new \DateTime('now'))
  584.             ->setName($parameters['event'])
  585.             ->setData($parameters['eventData']);
  587.         if( !empty($parameters['eventData']['origin']) && in_array($parameters['eventData']['origin'], PluginEventLog::ORIGINS) ){
  588.             $pluginEventLog->setOrigin($parameters['eventData']['origin']);
  589.         }
  591.         $em->persist($pluginEventLog);
  592.         $em->flush();
  594.         header(self::HEADERS);
  595.         return new JsonResponse(['status' => 'Ok'], 200);
  596.     }
  598.     /**
  599.      * @Route("/add_lot_data", name="add_lot_data", methods={"POST"})
  600.      * @param Request $request
  601.      * @param EntityManagerInterface $em
  602.      * @return Response
  603.      */
  604.     public function addLotData(Request $request, EntityManagerInterface $em): Response
  605.     {
  606.         $parameters = json_decode($request->getContent(), true);
  607.         if (empty($parameters['auction'])) {
  608.             header(self::HEADERS);
  609.             return new JsonResponse('Empty auction', 400);
  610.         }
  611.         if (empty($parameters['lot'])) {
  612.             header(self::HEADERS);
  613.             return new JsonResponse('Empty lot', 400);
  614.         }
  615.         if (empty($parameters['vin']) || str_contains('stars_', $parameters['vin'])) {
  616.             header(self::HEADERS);
  617.             return new JsonResponse('Wrong vin', 400);
  618.         }
  619.         if (!isset($parameters['data']) || empty($parameters['data']) || !is_array($parameters['data']) || !isset($parameters['data']['lotDetails'])) {
  620.             header(self::HEADERS);
  621.             return new JsonResponse('Bad data', 400);
  622.         }
  624.         $ip = CommonUtils::getClientIP($request);
  626.         $pluginEventLog = (new PluginLotData())
  627.             ->setIp($ip)
  628.             ->setCreatedAt(new \DateTimeImmutable('now'))
  629.             ->setLot($parameters['lot'])
  630.             ->setVin($parameters['vin'])
  631.             ->setPv($parameters['pv'])
  632.             ->setUserData($parameters['user_data'])
  633.             ->setData($parameters['data']);
  636.         if( !empty($parameters['auction']) && in_array($parameters['auction'], PluginLotData::AUCTIONS) ){
  637.             $pluginEventLog->setAuction($parameters['auction']);
  638.         }
  640.         $em->persist($pluginEventLog);
  641.         $em->flush();
  643.         header(self::HEADERS);
  644.         return new JsonResponse(['status' => 'Ok'], 200);
  645.     }
  647.     /**
  648.      * @Route("/get_auction", name="get_auction", methods={"POST"})
  649.      * @param Request $request
  650.      * @param EntityManagerInterface $em
  651.      * @return Response
  652.      */
  653.     public function get_auction(Request $request, EntityManagerInterface $em): Response
  654.     {
  655.         $request_body = $request->toArray();
  657.         $plugin_version = $request_body['pv'] ?? '';
  658.         $auction_name = strtolower(trim($request_body['auction_name'])) ?? '';
  659.         $ip = CommonUtils::getClientIP($request);
  661.         if(empty($auction_name)){
  662.             header(self::HEADERS);
  663.             return new JsonResponse('Invalid Request', 400);
  664.         }
  665.         if (empty($plugin_version)) {
  666.             header(self::HEADERS);
  667.             return new JsonResponse('Invalid pv', 400);
  668.         }
  672.         try {
  673.             $pluginToken = $this->_authUserByToken($em, $request);
  674.         } catch (BadRequestException $e) {
  675.             header(self::HEADERS);
  676.             return new JsonResponse('Bad Request', 400);
  677.         } catch (InvalidTokenException $e) {
  678.             header(self::HEADERS);
  680.         }
  682.         $available_accounts = $pluginToken->getPluginUser()->getCopartAccounts();
  683.         $AuctionAccounts = [];
  684.         foreach($available_accounts as $account) {
  685.             if (strtolower($account->getAuctionNameWithFullCountry()) === $auction_name) {
  686.                 $AuctionAccounts[] = $account;
  687.             }
  688.         }
  690.         $count = count($AuctionAccounts);
  691.         if ($count < 1) {
  692.             header(self::HEADERS);
  693.             return new JsonResponse('Invalid Auction accounts', 401);
  694.         }
  695.         $key = random_int(0, $count - 1);
  696.         $auctionAccount = $AuctionAccounts[$key];
  699.         $proxyAccount = $auctionAccount->getProxyAccount();
  700.         $proxy = [];
  701.         if ($proxyAccount) {
  702.             $proxy = [
  703.                     'host' => $proxyAccount->getProxyHost() ?? '',
  704.                     'port' => $proxyAccount->getProxyPort() ?? '',
  705.                     'username' => $proxyAccount->getProxyUsername() ?? '',
  706.                     'password' => $proxyAccount->getProxyPassword() ?? '',
  707.             ];
  708.         }
  710.         $vpn = [];
  711.         $vpn_required = false;
  713.         if($auction_name == 'cars-usa') { //TODO check if auction has vpn config.
  714.             $vpn = [
  715.                 'vpn_type' => 'openvpn',
  716.                 'vpn_config' => self::STATIC_VPN_CONFIG,
  717.             ];
  718.             $vpn_required = true;
  719.         }
  721.         $assigmentRepository = $em->getRepository(PluginUserAuctionAccountAssigment::class);
  722.         $pluginAuctionAssignment = $assigmentRepository->createAuctionAssignment($auctionAccount, $pluginToken, $plugin_version, $ip);
  724.         $data = [
  725.             'auction_credentials' => [
  726.                 'auction_name' => $auction_name,
  727.                 'login' => $pluginAuctionAssignment->getAuctionAccount()->getLogin() ?? '',
  728.                 'password' => $pluginAuctionAssignment->getAuctionAccount()->getPassword() ?? '',
  729.             ],
  730.             'assigment_id' => $pluginAuctionAssignment->getId(),
  731.             'proxy' => $proxy,
  732.             'vpn_options' => $vpn,
  733.             'vpn_required' => $vpn_required,
  734.         ];
  736.         header(self::HEADERS);
  737.         return new JsonResponse($data, 200);
  738.     }
  740.     /**
  741.      * @Route("/get_available_auctions", name="get_available_auctions", methods={"POST"})
  742.      * @param Request $request
  743.      * @param EntityManagerInterface $em
  744.      * @return Response
  745.      */
  746.     public function getAvailableAuctionAccounts(Request $request, EntityManagerInterface $em): Response
  747.     {
  748.         $data = [];
  749.         $_avail_auction_names = [];
  750.         $parameters = json_decode($request->getContent(), true) ?: [];
  751.         $allValue = $parameters['all'] ?? false;
  752.         $all = is_bool($allValue)
  753.             ? $allValue
  754.             : (is_int($allValue)
  755.                 ? $allValue === 1
  756.                 : (is_string($allValue) && in_array(strtolower(trim($allValue)), ['1', 'true', 'yes'], true)));
  757.         $auctionNameFilter = strtolower(trim((string)($parameters['auction_name'] ?? '')));
  758.         try {
  759.             $pluginToken = $this->_authUserByToken($em, $request);
  760.         } catch (BadRequestException $e) {
  761.             header(self::HEADERS);
  762.             return new JsonResponse('Bad Request', 400);
  763.         } catch (InvalidTokenException $e) {
  764.             header(self::HEADERS);
  765.             return new JsonResponse('Invalid token', 401);
  766.         }
  769.         $available_accounts = $pluginToken->getPluginUser()->getCopartAccounts();
  770.         foreach($available_accounts as $account) {
  771.             $fullAuctionName = strtolower((string)$account->getAuctionName() . '-' . (string)$account->getCountry());
  772.             $shortAuctionName = strtolower((string)$account->getAuctionName());
  773.             if (!empty($auctionNameFilter) && $auctionNameFilter !== $shortAuctionName && $auctionNameFilter !== $fullAuctionName) {
  774.                 continue;
  775.             }
  776.             if (!$all && in_array($account->getAuctionName().'-'.$account->getCountry(), $_avail_auction_names, true)) {
  777.                 continue;
  778.             }
  779.             $_avail_auction_names[] = $account->getAuctionName().'-'.$account->getCountry();
  780.             $id = $account->getId();
  781.             if (strtolower($account->getAuctionName()) === 'copart'){
  782.                 $id = 2;
  783.             } elseif (strtolower($account->getAuctionName()) === 'manheim'){
  784.                 $id = 11;
  785.             } elseif (strtolower($account->getAuctionName()) === 'iaai' && !is_null($account->getCountry())) {
  786.                 if (strtolower($account->getCountry()) === 'usa') {
  787.                     $id = 1;
  788.                 } elseif (strtolower($account->getCountry()) === 'canada') {
  789.                     $id = 12;
  790.                 }
  791.             } elseif (strtolower($account->getAuctionName()) === 'bringatrailer'){
  792.                 $id = 17;
  793.             } elseif (strtolower($account->getAuctionName()) === 'cars_and_bids'){
  794.                 $id = 20;
  795.             } elseif (strtolower($account->getAuctionName()) === 'cars'){
  796.                 $id = 23;
  797.             } elseif (strtolower($account->getAuctionName()) === 'cargurus'){
  798.                 $id = 26;
  799.             }
  800.             $data[] = [
  801.                 'id' => $id,
  802.                 'auction_account_id' => $account->getId(),
  803.                 'account_name' => $account->getCommonName() ?? '',
  804.                 'auction_name' => $account->getAuctionName(),
  805.                 'auction_country' => $account->getCountry(),
  806.                 'display_name' => ( is_null($account->getCountry()) || empty($account->getCountry()) ) ? strtoupper($account->getAuctionName()) : strtoupper($account->getAuctionName().'-'.$account->getCountry()),
  807.             ];
  808.         }
  810.         if (count($data) < 1) {
  811.             header(self::HEADERS);
  812.             return new JsonResponse('Invalid Auction accounts', 401);
  813.         }
  815.         header(self::HEADERS);
  816.         return new JsonResponse($data, 200);
  817.     }
  819.     /**
  820.      * @Route("/get_iaai_account", name="get_iaai_account", methods={"POST"})
  821.      * @param Request $request
  822.      * @param EntityManagerInterface $em
  823.      * @return Response
  824.      */
  825.     public function getIaaiAccount(Request $request, EntityManagerInterface $em): Response
  826.     {
  827.         try {
  828.             $pluginToken = $this->_authUserByToken($em, $request);
  829.         } catch (BadRequestException $e) {
  830.             header(self::HEADERS);
  831.             return new JsonResponse('Bad Request', 400);
  832.         } catch (InvalidTokenException $e) {
  833.             header(self::HEADERS);
  834.             return new JsonResponse('Invalid token', 401);
  835.         }
  836.         $parameters = json_decode($request->getContent(), true);
  837.         $plugin_version = $parameters['pv'] ?? '';
  838.         $allValue = $parameters['all'] ?? false;
  839.         $all = is_bool($allValue)
  840.             ? $allValue
  841.             : (is_int($allValue)
  842.                 ? $allValue === 1
  843.                 : (is_string($allValue) && in_array(strtolower(trim($allValue)), ['1', 'true', 'yes'], true)));
  844.         if (empty($plugin_version)) {
  845.             header(self::HEADERS);
  846.             return new JsonResponse('Invalid pv', 400);
  847.         }
  848.         $ip = CommonUtils::getClientIP($request);
  850.         /******* parse iaai redirect country *********/
  851.         $redirect_uri = $parameters['url'] ?? 'usa';
  852.         $country = 'usa';
  853.         if (!empty($redirect_uri)) {
  854.             parse_str(parse_url(urldecode($redirect_uri), PHP_URL_QUERY), $parsed_redirect_url);
  855.             if (!empty($parsed_redirect_url['redirect_uri'])) {
  856.                 if (strpos($parsed_redirect_url['redirect_uri'], 'ca.iaai.com') !== false) {
  857.                     $country = 'canada';
  858.                 } elseif (strpos($parsed_redirect_url['redirect_uri'], 'www.iaai.com') !== false) {
  859.                     $country = 'usa';
  860.                 }
  861.             }
  862.         }
  863.         /******* end *********/
  865.         $pluginUser = $pluginToken->getPluginUser();
  866.         $AuctionAccounts = [];
  867.         foreach ($pluginUser->getOnlyIaaiAccounts() as $aa) {
  868.             if ($aa->getCountry() === $country) {
  869.                 $AuctionAccounts[] = $aa;
  870.             }
  871.         }
  873.         if (count($AuctionAccounts) < 1) {
  874.             header(self::HEADERS);
  875.             return new JsonResponse('Invalid Iaai accounts', 401);
  876.         }
  878.         $accountFinancesAccesses = $pluginUser->getAccountsFinancesAccessMap();
  879.         $assigmentRepository = $em->getRepository(PluginUserAuctionAccountAssigment::class);
  881.         if ($all) {
  882.             $allIaaiAccounts = [];
  883.             foreach ($AuctionAccounts as $auctionAccount) {
  884.                 $canManagePayments = $accountFinancesAccesses[$auctionAccount->getId()] ?? false;
  885.                 $accountData = [
  886.                     'id' => $auctionAccount->getId(),
  887.                     'auction_account_id' => $auctionAccount->getId(),
  888.                     'account_name' => $auctionAccount->getCommonName() ?? '',
  889.                     'login' => $auctionAccount->getLogin() ?? '',
  890.                     'password' => $auctionAccount->getPassword() ?? '',
  891.                     'can_manage_payments' => $canManagePayments,
  892.                     'country' => $auctionAccount->getCountry(),
  893.                 ];
  894.                 $proxyAccount = $auctionAccount->getProxyAccount();
  895.                 $proxy = [];
  896.                 if ($proxyAccount) {
  897.                     $proxy = [
  898.                         'proxy' => [
  899.                             'host' => $proxyAccount->getProxyHost() ?? '',
  900.                             'port' => $proxyAccount->getProxyPort() ?? '',
  901.                             'username' => $proxyAccount->getProxyUsername() ?? '',
  902.                             'password' => $proxyAccount->getProxyPassword() ?? '',
  903.                         ]
  904.                     ];
  905.                 }
  906.                 if (!empty($proxy)) {
  907.                     $accountData['proxy'] = $proxy['proxy'];
  908.                 }
  909.                 $allIaaiAccounts[] = $accountData;
  910.             }
  912.             header(self::HEADERS);
  913.             return new JsonResponse(['iaai_accounts' => $allIaaiAccounts], 200);
  914.         }
  916.         $auctionAccount = $assigmentRepository->selectAuctionAccountForAssigment($AuctionAccounts, $accountFinancesAccesses);
  917.         $pluginAuctionAssignment = $assigmentRepository->createAuctionAssignment($auctionAccount, $pluginToken, $plugin_version, $ip);
  919.         $canManagePayments = $accountFinancesAccesses[$auctionAccount->getId()] ?? false;
  921.         $proxyAccount = $auctionAccount->getProxyAccount();
  922.         $proxy = [];
  923.         if ($proxyAccount) {
  924.             $proxy = [
  925.                 'proxy' => [
  926.                     'host' => $proxyAccount->getProxyHost() ?? '',
  927.                     'port' => $proxyAccount->getProxyPort() ?? '',
  928.                     'username' => $proxyAccount->getProxyUsername() ?? '',
  929.                     'password' => $proxyAccount->getProxyPassword() ?? '',
  930.                 ]
  931.             ];
  932.         }
  934.         $data = [
  935.             'iaai' => [
  936.                 'id' => $pluginAuctionAssignment->getAuctionAccount()->getId(),
  937.                 'account_name' => $pluginAuctionAssignment->getAuctionAccount()->getCommonName() ?? '',
  938.                 'login' => $pluginAuctionAssignment->getAuctionAccount()->getLogin() ?? '',
  939.                 'password' => $pluginAuctionAssignment->getAuctionAccount()->getPassword() ?? '',
  940.             ],
  941.             'assigment_id' => $pluginAuctionAssignment->getId(),
  942.             'can_manage_payments' => $canManagePayments,
  943.         ];
  944.         header(self::HEADERS);
  945.         return new JsonResponse(array_merge($data, $proxy), 200);
  946.     }
  948.     /**
  949.      * @Route("/get_manheim_account", name="get_manheim_account", methods={"POST"})
  950.      * @param Request $request
  951.      * @param EntityManagerInterface $em
  952.      * @return Response
  953.      */
  954.     public function getManheimAccount(Request $request, EntityManagerInterface $em): Response
  955.     {
  956.         try {
  957.             $pluginToken = $this->_authUserByToken($em, $request);
  958.         } catch (BadRequestException $e) {
  959.             header(self::HEADERS);
  960.             return new JsonResponse('Bad Request', 400);
  961.         } catch (InvalidTokenException $e) {
  962.             header(self::HEADERS);
  963.             return new JsonResponse('Invalid token', 401);
  964.         }
  965.         $parameters = json_decode($request->getContent(), true);
  966.         $plugin_version = $parameters['pv'] ?? '';
  967.         $allValue = $parameters['all'] ?? false;
  968.         $all = is_bool($allValue)
  969.             ? $allValue
  970.             : (is_int($allValue)
  971.                 ? $allValue === 1
  972.                 : (is_string($allValue) && in_array(strtolower(trim($allValue)), ['1', 'true', 'yes'], true)));
  973.         if (empty($plugin_version)) {
  974.             header(self::HEADERS);
  975.             return new JsonResponse('Invalid pv', 400);
  976.         }
  977.         $ip = CommonUtils::getClientIP($request);
  979.         $pluginUser = $pluginToken->getPluginUser();
  980.         $AuctionAccounts = $pluginUser->getOnlyManheimAccounts();
  982.         if (count($AuctionAccounts) < 1) {
  983.             header(self::HEADERS);
  984.             return new JsonResponse('Invalid Manheim accounts', 401);
  985.         }
  987.         $accountFinancesAccesses = $pluginUser->getAccountsFinancesAccessMap();
  988.         $assigmentRepository = $em->getRepository(PluginUserAuctionAccountAssigment::class);
  990.         if ($all) {
  991.             $allManheimAccounts = [];
  992.             foreach ($AuctionAccounts as $auctionAccount) {
  993.                 $canManagePayments = $accountFinancesAccesses[$auctionAccount->getId()] ?? false;
  994.                 $accountData = [
  995.                     'id' => $auctionAccount->getId(),
  996.                     'auction_account_id' => $auctionAccount->getId(),
  997.                     'account_name' => $auctionAccount->getCommonName() ?? '',
  998.                     'login' => $auctionAccount->getLogin() ?? '',
  999.                     'password' => $auctionAccount->getPassword() ?? '',
  1000.                     'can_manage_payments' => $canManagePayments,
  1001.                 ];
  1002.                 $proxyAccount = $auctionAccount->getProxyAccount();
  1003.                 $proxy = [];
  1004.                 if ($proxyAccount) {
  1005.                     $proxy = [
  1006.                         'proxy' => [
  1007.                             'host' => $proxyAccount->getProxyHost() ?? '',
  1008.                             'port' => $proxyAccount->getProxyPort() ?? '',
  1009.                             'username' => $proxyAccount->getProxyUsername() ?? '',
  1010.                             'password' => $proxyAccount->getProxyPassword() ?? '',
  1011.                         ]
  1012.                     ];
  1013.                 }
  1014.                 if (!empty($proxy)) {
  1015.                     $accountData['proxy'] = $proxy['proxy'];
  1016.                 }
  1017.                 $allManheimAccounts[] = $accountData;
  1018.             }
  1020.             header(self::HEADERS);
  1021.             return new JsonResponse(['manheim_accounts' => $allManheimAccounts], 200);
  1022.         }
  1024.         $auctionAccount = $assigmentRepository->selectAuctionAccountForAssigment($AuctionAccounts, $accountFinancesAccesses);
  1025.         $pluginAuctionAssignment = $assigmentRepository->createAuctionAssignment($auctionAccount, $pluginToken, $plugin_version, $ip);
  1027.         $canManagePayments = $accountFinancesAccesses[$auctionAccount->getId()] ?? false;
  1029. //        $login = $auctionAccount->getLogin();
  1030. //        $password = $auctionAccount->getPassword();
  1031.         // $proxyAccount = $auctionAccount->getProxyAccount();
  1033.         $em = $this->getDoctrine()->getManager();
  1034.         $proxyAccount = $em->getRepository(ProxyAccount::class)->findLastUsedManheimProxy();
  1036.         $proxy = [];
  1037.         if ($proxyAccount) {
  1038.             $proxy = [
  1039.                 'proxy' => [
  1040.                     'host' => $proxyAccount->getProxyHost() ?? '',
  1041.                     'port' => $proxyAccount->getProxyPort() ?? '',
  1042.                     'username' => $proxyAccount->getProxyUsername() ?? '',
  1043.                     'password' => $proxyAccount->getProxyPassword() ?? '',
  1044.                 ]
  1045.             ];
  1047.             $proxyAccount->setLastUsedAt(new \DateTime('now'));
  1048.             $em->persist($proxyAccount);
  1049.         }
  1051.         $data = [
  1052.             'manheim' => [
  1053.                 'id' => $pluginAuctionAssignment->getAuctionAccount()->getId(),
  1054.                 'account_name' => $pluginAuctionAssignment->getAuctionAccount()->getCommonName() ?? '',
  1055.                 'login' => $pluginAuctionAssignment->getAuctionAccount()->getLogin() ?? '',
  1056.                 'password' => $pluginAuctionAssignment->getAuctionAccount()->getPassword() ?? '',
  1057.             ],
  1058.             'assigment_id' => $pluginAuctionAssignment->getId(),
  1059.             'can_manage_payments' => $canManagePayments,
  1060.         ];
  1061.         header(self::HEADERS);
  1062.         return new JsonResponse(array_merge($data, $proxy), 200);
  1063.     }
  1065.     /**
  1066.      * @Route("/create_assigment_log", name="create_assigment_log", methods={"POST"})
  1067.      * @return Response
  1068.      */
  1069.     public function createAssigmentLog(Request $request, EntityManagerInterface $em): Response
  1070.     {
  1071.         $parameters = json_decode($request->getContent(), true);
  1072.         $auctionAccountId = $parameters['id'] ?? null;
  1073.         $token = $parameters['token'] ?? '';
  1074.         $pluginVersion = $parameters['pv'] ?? '';
  1076.         if (empty($auctionAccountId) || empty($token)) {
  1077.             header(self::HEADERS);
  1078.             return new JsonResponse('Bad Request', 400);
  1079.         }
  1081.         $pluginToken = $em->getRepository(PluginToken::class)->findOneBy(['token' => $token, 'status' => 'on']);
  1082.         if (!$pluginToken instanceof PluginToken) {
  1083.             header(self::HEADERS);
  1084.             return new JsonResponse('Invalid token', 401);
  1085.         }
  1087.         $pluginUser = $pluginToken->getPluginUser();
  1088.         if (!$pluginUser->getOwner()->getEnablePlugin() || $pluginUser->getDeleted()) {
  1089.             header(self::HEADERS);
  1090.             return new JsonResponse('Invalid token', 401);
  1091.         }
  1093.         $auctionAccount = $em->getRepository(AuctionAccount::class)->find((int)$auctionAccountId);
  1094.         if (!$auctionAccount instanceof AuctionAccount) {
  1095.             header(self::HEADERS);
  1096.             return new JsonResponse('Invalid account id', 406);
  1097.         }
  1099.         $allowed = false;
  1100.         foreach ($pluginUser->getCopartAccounts() as $userAuctionAccount) {
  1101.             if ($userAuctionAccount->getId() === $auctionAccount->getId()) {
  1102.                 $allowed = true;
  1103.                 break;
  1104.             }
  1105.         }
  1106.         if (!$allowed) {
  1107.             header(self::HEADERS);
  1108.             return new JsonResponse('Invalid account id', 406);
  1109.         }
  1111.         $ip = CommonUtils::getClientIP($request);
  1112.         $assigmentRepository = $em->getRepository(PluginUserAuctionAccountAssigment::class);
  1113.         $pluginAuctionAssignment = $assigmentRepository->createAuctionAssignment(
  1114.             $auctionAccount,
  1115.             $pluginToken,
  1116.             (string)$pluginVersion,
  1117.             $ip
  1118.         );
  1120.         header(self::HEADERS);
  1121.         return new JsonResponse([
  1122.             'status' => 'Ok',
  1123.             'assigment_id' => $pluginAuctionAssignment->getId(),
  1124.         ], 200);
  1125.     }
  1127.     /**
  1128.      * @Route("/manheim_2fa_codes", name="manheim_2fa_code", methods={"POST"})
  1129.      * @param AccountCodeRepository $accountCodeRepository
  1130.      * @param EntityManagerInterface $em
  1131.      * @param Request $request
  1132.      * @return Response
  1133.      */
  1134.     public function getManheim2FACodes(AccountCodeRepository $accountCodeRepository, EntityManagerInterface $em, Request $request): Response
  1135.     {
  1136.         try {
  1137.             $pluginToken = $this->_authUserByToken($em, $request);
  1138.         } catch (BadRequestException $e) {
  1139.             header(self::HEADERS);
  1140.             return new JsonResponse('Bad Request', 400);
  1141.         } catch (InvalidTokenException $e) {
  1142.             header(self::HEADERS);
  1143.             return new JsonResponse('Invalid token', 401);
  1144.         }
  1146.         $auctionAccounts = $pluginToken->getPluginUser()->getOnlyManheimAccounts();
  1147.         $count = count($auctionAccounts);
  1148.         if ($count < 1) {
  1149.             header(self::HEADERS);
  1150.             return new JsonResponse('Invalid Manheim accounts', 401);
  1151.         }
  1153.         $manheimCodes = $accountCodeRepository->getLatestCodesByAccountType('manheim');
  1154.         $resultCodes = [];
  1155.         foreach ($manheimCodes as $code) {
  1156.             $resultCodes[] = [
  1157.                 '2fa_code' => $code->getCode(),
  1158.                 'received_at' => $code->getReceivedAt()->format('c'), // ISO 8601 format,
  1159.             ];
  1160.         }
  1161.         $data = [
  1162.             'manheim_codes' => $resultCodes
  1163.         ];
  1165.         header(self::HEADERS);
  1166.         return new JsonResponse($data, 200);
  1167.     }
  1169.     /**
  1170.      * @Route("/get_bringatrailer_account", name="get_bringatrailer_account", methods={"POST"})
  1171.      * @param Request $request
  1172.      * @param EntityManagerInterface $em
  1173.      * @return Response
  1174.      */
  1175.     public function getBringatrailerAccount(Request $request, EntityManagerInterface $em): Response
  1176.     {
  1177.         try {
  1178.             $pluginToken = $this->_authUserByToken($em, $request);
  1179.         } catch (BadRequestException $e) {
  1180.             header(self::HEADERS);
  1181.             return new JsonResponse('Bad Request', 400);
  1182.         } catch (InvalidTokenException $e) {
  1183.             header(self::HEADERS);
  1184.             return new JsonResponse('Invalid token', 401);
  1185.         }
  1186.         $parameters = json_decode($request->getContent(), true);
  1187.         $plugin_version = $parameters['pv'] ?? '';
  1188.         if (empty($plugin_version)) {
  1189.             header(self::HEADERS);
  1190.             return new JsonResponse('Invalid pv', 400);
  1191.         }
  1192.         $ip = CommonUtils::getClientIP($request);
  1194.         $pluginUser = $pluginToken->getPluginUser();
  1195.         $AuctionAccounts = $pluginUser->getOnlyBringatrailerAccounts();
  1197.         if (count($AuctionAccounts) < 1) {
  1198.             header(self::HEADERS);
  1199.             return new JsonResponse('Invalid Bringatrailer accounts', 401);
  1200.         }
  1202.         $accountFinancesAccesses = $pluginUser->getAccountsFinancesAccessMap();
  1203.         $assigmentRepository = $em->getRepository(PluginUserAuctionAccountAssigment::class);
  1204.         $auctionAccount = $assigmentRepository->selectAuctionAccountForAssigment($AuctionAccounts, $accountFinancesAccesses);
  1205.         $pluginAuctionAssignment = $assigmentRepository->createAuctionAssignment($auctionAccount, $pluginToken, $plugin_version, $ip);
  1207.         $canManagePayments = $accountFinancesAccesses[$auctionAccount->getId()] ?? false;
  1209. //        $login = $auctionAccount->getLogin();
  1210. //        $password = $auctionAccount->getPassword();
  1211.         $proxyAccount = $auctionAccount->getProxyAccount();
  1212.         $proxy = [];
  1213.         if ($proxyAccount) {
  1214.             $proxy = [
  1215.                 'proxy' => [
  1216.                     'host' => $proxyAccount->getProxyHost() ?? '',
  1217.                     'port' => $proxyAccount->getProxyPort() ?? '',
  1218.                     'username' => $proxyAccount->getProxyUsername() ?? '',
  1219.                     'password' => $proxyAccount->getProxyPassword() ?? '',
  1220.                 ]
  1221.             ];
  1222.         }
  1224.         $data = [
  1225.             'bringatrailer' => [
  1226.                 'login' => $pluginAuctionAssignment->getAuctionAccount()->getLogin() ?? '',
  1227.                 'password' => $pluginAuctionAssignment->getAuctionAccount()->getPassword() ?? '',
  1228.             ],
  1229.             'assigment_id' => $pluginAuctionAssignment->getId(),
  1230.             'can_manage_payments' => $canManagePayments,
  1231.         ];
  1232.         header(self::HEADERS);
  1233.         return new JsonResponse(array_merge($data, $proxy), 200);
  1234.     }
  1236.     /**
  1237.      * @Route("/get_cars_and_bids_account", name="get_cars_and_bids_account", methods={"POST"})
  1238.      * @param Request $request
  1239.      * @param EntityManagerInterface $em
  1240.      * @return Response
  1241.      */
  1242.     public function getCarsAndBidsAccount(Request $request, EntityManagerInterface $em): Response
  1243.     {
  1244.         try {
  1245.             $pluginToken = $this->_authUserByToken($em, $request);
  1246.         } catch (BadRequestException $e) {
  1247.             header(self::HEADERS);
  1248.             return new JsonResponse('Bad Request', 400);
  1249.         } catch (InvalidTokenException $e) {
  1250.             header(self::HEADERS);
  1251.             return new JsonResponse('Invalid token', 401);
  1252.         }
  1253.         $parameters = json_decode($request->getContent(), true);
  1254.         $plugin_version = $parameters['pv'] ?? '';
  1255.         if (empty($plugin_version)) {
  1256.             header(self::HEADERS);
  1257.             return new JsonResponse('Invalid pv', 400);
  1258.         }
  1259.         $ip = CommonUtils::getClientIP($request);
  1261.         $pluginUser = $pluginToken->getPluginUser();
  1262.         $AuctionAccounts = $pluginUser->getOnlyCarsAndBidsAccounts();
  1264.         if (count($AuctionAccounts) < 1) {
  1265.             header(self::HEADERS);
  1266.             return new JsonResponse('Invalid Cars_and_bids accounts', 401);
  1267.         }
  1269.         $accountFinancesAccesses = $pluginUser->getAccountsFinancesAccessMap();
  1270.         $assigmentRepository = $em->getRepository(PluginUserAuctionAccountAssigment::class);
  1271.         $auctionAccount = $assigmentRepository->selectAuctionAccountForAssigment($AuctionAccounts, $accountFinancesAccesses);
  1272.         $pluginAuctionAssignment = $assigmentRepository->createAuctionAssignment($auctionAccount, $pluginToken, $plugin_version, $ip);
  1274.         $canManagePayments = $accountFinancesAccesses[$auctionAccount->getId()] ?? false;
  1276. //        $login = $auctionAccount->getLogin();
  1277. //        $password = $auctionAccount->getPassword();
  1278.         $proxyAccount = $auctionAccount->getProxyAccount();
  1279.         $proxy = [];
  1280.         if ($proxyAccount) {
  1281.             $proxy = [
  1282.                 'proxy' => [
  1283.                     'host' => $proxyAccount->getProxyHost() ?? '',
  1284.                     'port' => $proxyAccount->getProxyPort() ?? '',
  1285.                     'username' => $proxyAccount->getProxyUsername() ?? '',
  1286.                     'password' => $proxyAccount->getProxyPassword() ?? '',
  1287.                 ]
  1288.             ];
  1289.         }
  1291.         $data = [
  1292.             'cars_and_bids' => [
  1293.                 'login' => $pluginAuctionAssignment->getAuctionAccount()->getLogin() ?? '',
  1294.                 'password' => $pluginAuctionAssignment->getAuctionAccount()->getPassword() ?? '',
  1295.             ],
  1296.             'assigment_id' => $pluginAuctionAssignment->getId(),
  1297.             'can_manage_payments' => $canManagePayments,
  1298.         ];
  1299.         header(self::HEADERS);
  1300.         return new JsonResponse(array_merge($data, $proxy), 200);
  1301.     }
  1303.     /**
  1304.      * @Route("/get_cars_account", name="get_cars_account", methods={"POST"})
  1305.      * @param Request $request
  1306.      * @param EntityManagerInterface $em
  1307.      * @return Response
  1308.      */
  1309.     public function getCarsAccount(Request $request, EntityManagerInterface $em): Response
  1310.     {
  1311.         try {
  1312.             $pluginToken = $this->_authUserByToken($em, $request);
  1313.         } catch (BadRequestException $e) {
  1314.             header(self::HEADERS);
  1315.             return new JsonResponse('Bad Request', 400);
  1316.         } catch (InvalidTokenException $e) {
  1317.             header(self::HEADERS);
  1318.             return new JsonResponse('Invalid token', 401);
  1319.         }
  1320.         $parameters = json_decode($request->getContent(), true);
  1321.         $plugin_version = $parameters['pv'] ?? '';
  1322.         if (empty($plugin_version)) {
  1323.             header(self::HEADERS);
  1324.             return new JsonResponse('Invalid pv', 400);
  1325.         }
  1326.         $ip = CommonUtils::getClientIP($request);
  1328.         $pluginUser = $pluginToken->getPluginUser();
  1329.         $AuctionAccounts = $pluginUser->getOnlyCarsAccounts();
  1331.         if (count($AuctionAccounts) < 1) {
  1332.             header(self::HEADERS);
  1333.             return new JsonResponse('Invalid Cars accounts', 401);
  1334.         }
  1336.         $accountFinancesAccesses = $pluginUser->getAccountsFinancesAccessMap();
  1337.         $assigmentRepository = $em->getRepository(PluginUserAuctionAccountAssigment::class);
  1338.         $auctionAccount = $assigmentRepository->selectAuctionAccountForAssigment($AuctionAccounts, $accountFinancesAccesses);
  1339.         $pluginAuctionAssignment = $assigmentRepository->createAuctionAssignment($auctionAccount, $pluginToken, $plugin_version, $ip);
  1341.         $canManagePayments = $accountFinancesAccesses[$auctionAccount->getId()] ?? false;
  1343.         $proxyAccount = $auctionAccount->getProxyAccount();
  1344.         $proxy = [];
  1345.         if ($proxyAccount) {
  1346.             $proxy = [
  1347.                 'proxy' => [
  1348.                     'host' => $proxyAccount->getProxyHost() ?? '',
  1349.                     'port' => $proxyAccount->getProxyPort() ?? '',
  1350.                     'username' => $proxyAccount->getProxyUsername() ?? '',
  1351.                     'password' => $proxyAccount->getProxyPassword() ?? '',
  1352.                 ]
  1353.             ];
  1354.         }
  1356.         $data = [
  1357.             'cars' => [
  1358.                 'login' => $pluginAuctionAssignment->getAuctionAccount()->getLogin() ?? '',
  1359.                 'password' => $pluginAuctionAssignment->getAuctionAccount()->getPassword() ?? '',
  1360.             ],
  1361.             'assigment_id' => $pluginAuctionAssignment->getId(),
  1362.             'can_manage_payments' => $canManagePayments,
  1363.         ];
  1364.         header(self::HEADERS);
  1365.         return new JsonResponse(array_merge($data, $proxy), 200);
  1366.     }
  1368.     /**
  1369.      * @Route("/get_cargurus_account", name="get_cargurus_account", methods={"POST"})
  1370.      * @param Request $request
  1371.      * @param EntityManagerInterface $em
  1372.      * @return Response
  1373.      */
  1374.     public function getCargurusAccount(Request $request, EntityManagerInterface $em): Response
  1375.     {
  1376.         try {
  1377.             $pluginToken = $this->_authUserByToken($em, $request);
  1378.         } catch (BadRequestException $e) {
  1379.             header(self::HEADERS);
  1380.             return new JsonResponse('Bad Request', 400);
  1381.         } catch (InvalidTokenException $e) {
  1382.             header(self::HEADERS);
  1383.             return new JsonResponse('Invalid token', 401);
  1384.         }
  1385.         $parameters = json_decode($request->getContent(), true);
  1386.         $plugin_version = $parameters['pv'] ?? '';
  1387.         if (empty($plugin_version)) {
  1388.             header(self::HEADERS);
  1389.             return new JsonResponse('Invalid pv', 400);
  1390.         }
  1391.         $ip = CommonUtils::getClientIP($request);
  1393.         $pluginUser = $pluginToken->getPluginUser();
  1394.         $AuctionAccounts = $pluginUser->getOnlyCargurusAccounts();
  1396.         if (count($AuctionAccounts) < 1) {
  1397.             header(self::HEADERS);
  1398.             return new JsonResponse('Invalid Cargurus accounts', 401);
  1399.         }
  1401.         $accountFinancesAccesses = $pluginUser->getAccountsFinancesAccessMap();
  1402.         $assigmentRepository = $em->getRepository(PluginUserAuctionAccountAssigment::class);
  1403.         $auctionAccount = $assigmentRepository->selectAuctionAccountForAssigment($AuctionAccounts, $accountFinancesAccesses);
  1404.         $pluginAuctionAssignment = $assigmentRepository->createAuctionAssignment($auctionAccount, $pluginToken, $plugin_version, $ip);
  1406.         $canManagePayments = $accountFinancesAccesses[$auctionAccount->getId()] ?? false;
  1408.         $proxyAccount = $auctionAccount->getProxyAccount();
  1409.         $proxy = [];
  1410.         if ($proxyAccount) {
  1411.             $proxy = [
  1412.                 'proxy' => [
  1413.                     'host' => $proxyAccount->getProxyHost() ?? '',
  1414.                     'port' => $proxyAccount->getProxyPort() ?? '',
  1415.                     'username' => $proxyAccount->getProxyUsername() ?? '',
  1416.                     'password' => $proxyAccount->getProxyPassword() ?? '',
  1417.                 ]
  1418.             ];
  1419.         }
  1421.         $data = [
  1422.             'cargurus' => [
  1423.                 'login' => $pluginAuctionAssignment->getAuctionAccount()->getLogin() ?? '',
  1424.                 'password' => $pluginAuctionAssignment->getAuctionAccount()->getPassword() ?? '',
  1425.             ],
  1426.             'assigment_id' => $pluginAuctionAssignment->getId(),
  1427.             'can_manage_payments' => $canManagePayments,
  1428.         ];
  1429.         header(self::HEADERS);
  1430.         return new JsonResponse(array_merge($data, $proxy), 200);
  1431.     }
  1433.     /**
  1434.      * @Route("/send_app_debug", name="send_app_debug", methods={"POST"})
  1435.      * @param Request $request
  1436.      * @param EntityManagerInterface $em
  1437.      * @return Response
  1438.      */
  1439.     public function sendAppDebug(Request $request, EntityManagerInterface $em): Response
  1440.     {
  1441.         $plugin_login = $request->get('plugin_login', '');
  1443.         $plugin_user = $em->getRepository(PluginUser::class)->findOneBy(['login' => $plugin_login]);
  1444.         //TODO: add checking if is set debug flag for plugin user
  1445.         if (!$plugin_user instanceof PluginUser) {
  1446.             return new JsonResponse('Invalid user', 401);
  1447.         }
  1449.         $date = (new \DateTime('now'))->format('Y-m-d');
  1450.         $files = $request->files->all();
  1452.         if(!array_key_exists('files', $files)) {
  1453.             return new JsonResponse('File error', Response::HTTP_BAD_REQUEST, []);
  1454.         }
  1456.         $files = $files['files'];
  1457.         $files_uploaded = $this->_uploadedFiles( $files,"fk_o1z_app_logs/{$plugin_login}/{$date}" );
  1459.         $result = [
  1460.             'status'=>'Success',
  1461.             'message' => 'Logs are successfully saved',
  1462.             'files_url' => $files_uploaded, //TODO: Remove after debug!
  1463.         ];
  1465.         return new JsonResponse($result, 200, []);
  1466.     }
  1468.     private function _uploadedFiles($added_files_set, $store_path){
  1469.         $_files = [];
  1471.         if (!empty($added_files_set)) {
  1472.             foreach ($added_files_set as $_newFile) {
  1473.                 if($_newFile instanceof UploadedFile) {
  1474.                     $new_file_path = $this->fileUploader->upload($store_path, $_newFile, '');
  1475.                     if ($new_file_path) {
  1476.                         $_files[] = $this->fileUploader->getAbsoluteURLToFile($new_file_path);
  1477.                     }
  1478.                 }
  1479.             }
  1480.         }
  1481.         return $_files;
  1482.     }
  1484.     /**
  1485.      * @Route("/check_app_updates", name="check_app_updates", methods={"POST"})
  1486.      * @param Request $request
  1487.      * @param EntityManagerInterface $em
  1488.      * @return Response
  1489.      */
  1490.     public function checkAppUpdates(Request $request, EntityManagerInterface $em): Response
  1491.     {
  1492.         try {
  1493.             $pluginToken = $this->_authUserByToken($em, $request);
  1494.         } catch (BadRequestException $e) {
  1495.             header(self::HEADERS);
  1496.             return new JsonResponse('Bad Request', 400);
  1497.         } catch (InvalidTokenException $e) {
  1498.             header(self::HEADERS);
  1499.             return new JsonResponse('Invalid token', 401);
  1500.         }
  1502.         $parameters = json_decode($request->getContent(), true);
  1504.         //TODO: This is only for test. Make Production checks !!!
  1505.         $data = [
  1506.           'update_available' => false,
  1507.           'update_required' => false,
  1508.         ];
  1509.         $platform = $parameters['platform'] ?? '';
  1510.         $version = $parameters['version'] ?? '';
  1512.         if($platform == 'windows' && $version == '0.3.33') {
  1513.             $data['update_available'] = true;
  1514.             $data['update_required'] = false;
  1515.             $data['update_link'] =  'http://my.zvigerauto.com/Setup_ZvigerautoAuction_v0334.exe';
  1516.             $data['update_message'] = 'New Version is available';
  1517.         }
  1519.         if($platform == 'windows' && $version == '0.3.32') {
  1520.             $data['update_available'] = true;
  1521.             $data['update_required'] = true;
  1522.             $data['update_link'] =  'http://my.zvigerauto.com/Setup_ZvigerautoAuction_v0334.exe';
  1523.             $data['update_message'] = 'New Version is available';
  1524.         }
  1526.         return new JsonResponse(['data'=>$data], Response::HTTP_OK, []);
  1527.     }
  1528. }