src/Controller/Client/MarzbanController.php line 41

Open in your IDE?
  1. <?php
  3. namespace App\Controller\Client;
  6. use App\Entity\VPN\Service\Service;
  7. use App\Entity\VPN\Service\ServiceUsage;
  8. use App\Entity\VPN\V2ray\Server;
  9. use App\Repository\VPN\Service\ServiceRepository;
  10. use App\Repository\VPN\Service\ServiceUsageRepository;
  11. use App\Repository\VPN\V2ray\ServerRepository;
  12. use App\Service\Util\MarzbanNewAPI;
  13. use App\Service\Util\NotificationService;
  14. use App\Service\Util\ServersAnalyticsUsageService;
  15. use App\Service\Util\Telegram;
  16. use DateTime;
  17. use Doctrine\ORM\EntityManagerInterface;
  18. use Exception;
  19. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  20. use Symfony\Component\HttpFoundation\JsonResponse;
  21. use Symfony\Component\HttpFoundation\Request;
  22. use Symfony\Component\Routing\Annotation\Route;
  23. use Symfony\Component\Stopwatch\Stopwatch;
  25. //class MarzbanController extends AbstractController
  26. //{
  27. //    public $registry;
  28. //    private Telegram $telegram;
  29. //    public EntityManagerInterface $entityManager;
  30. //
  31. //    public ServiceUsageRepository $serviceUsageRepository;
  32. //
  33. //    public function __construct(Telegram $telegram, EntityManagerInterface $entityManager , ServiceUsageRepository $serviceUsageRepository)
  34. //    {
  35. //        $this->telegram = $telegram;
  36. //        $this->serviceUsageRepository = $serviceUsageRepository;
  37. //        $this->entityManager = $entityManager;
  38. //    }
  39. //
  40. //
  41. ////    Entity Manager Is Closed Problem
  42. ////    #[Route('/client/marzban', name: 'app_client_marzban')]
  43. ////    public function index(
  44. ////        Request           $request,
  45. ////        ServiceRepository $serviceRepository,
  46. ////        ServerRepository $serverRepository,
  47. ////        NotificationService $notificationService
  48. ////    ): JsonResponse
  49. ////    {
  50. ////
  51. //////        return new JsonResponse('TEst', JsonResponse::HTTP_BAD_REQUEST);
  52. ////
  53. ////
  54. ////        $entityManager = $this->getDoctrine()->getManager();
  55. ////        $this->registry = $entityManager;
  56. ////        $now = new DateTime();
  57. ////        $currentHour = (int)$now->format('H');
  58. ////        $data = json_decode($request->getContent(), true);
  59. ////        if (json_last_error() !== JSON_ERROR_NONE || !isset($data['ip'], $data['list'])) {
  60. ////            return new JsonResponse('Invalid JSON or missing data', JsonResponse::HTTP_BAD_REQUEST);
  61. ////        }
  62. ////
  63. ////        sleep(random_int(60 , 500));
  64. ////        $stopwatch = new Stopwatch();
  65. ////        // Start the stopwatch
  66. ////        $stopwatch->start('duration');
  67. ////        $users = $data['list'];
  68. ////        $usersCount = count($users);
  69. ////        $ip = $data['ip'];
  70. ////        $totalServerUsage = 0;
  71. ////        foreach ($users as $key => $userItem) {
  72. ////            if ($userItem['used_traffic'] > 0) {
  73. ////                $totalServerUsage = $totalServerUsage + $userItem['used_traffic'];
  74. ////            }
  75. ////        }
  76. ////        $analytics = new ServersAnalyticsUsageService($ip, $this->entityManager);
  77. ////        $analytics->addServerUsage($ip, $totalServerUsage);
  78. ////        $server = $this->getServer($ip, $serverRepository);
  79. ////        if (!$server) {
  80. ////            $this->telegram->sendRawMessage($ip);
  81. ////            return new JsonResponse('Server not found', JsonResponse::HTTP_BAD_REQUEST);
  82. ////        }
  83. ////        $server->setLastScriptUpdate(new \DateTimeImmutable());
  84. ////        $this->entityManager->flush();
  85. ////        // Split users into batches of 50 to handle them in smaller transactions
  86. ////        $arrayData = array_chunk($users, 50);
  87. ////        foreach ($arrayData as $arrayDatum) {
  88. ////            try {
  89. ////                // Start a transaction for this batch
  90. ////                $entityManager->beginTransaction();
  91. ////
  92. ////                foreach ($arrayDatum as $userArray) {
  93. ////                    try {
  94. ////                        $username = $userArray['username'];
  95. ////                        $calculationVolume = 1.2;
  96. ////                        if ($server->getCountry()->getCode() === 'ir'){
  97. ////                            $calculationVolume = 2;
  98. ////                        }
  99. ////                        foreach ($server->getProtocols() as $protocol) {
  100. ////                            if ($protocol->getCountry() !== null &&  $protocol->getCountry()->getCode() === 'ir'){
  101. ////                                $calculationVolume = 2;
  102. ////                            }
  103. ////                        }
  104. ////                        $usedTraffic = $userArray['used_traffic'] ?? 0;
  105. ////                        $usedTraffic = $usedTraffic * $calculationVolume;
  106. ////
  107. ////
  108. ////
  109. ////
  110. ////
  111. ////                        // Only handle users with traffic usage
  112. ////                        if ($usedTraffic > 0) {
  113. ////                            $service = $this->findService($username,$serviceRepository);
  114. ////                            if ($service) {
  115. ////                                $this->handleServiceUsage($server, $service, $usedTraffic);
  116. ////                                if (!$service->getExpireAt())
  117. ////                                {
  118. ////                                    $now = new \DateTimeImmutable();
  119. ////                                    $expiredAt =  $now->add(new \DateInterval("P{$service->getPlan()->getDays()}D"));
  120. ////                                    $service->setExpireAt($expiredAt);
  121. ////                                    $entityManager->flush();
  122. ////                                }
  123. ////                                if ($service->getPlan()->getServiceType() === 'unlimited' && $service->getCountry() !== $server->getCountry()->getCode()){
  124. ////                                    $this->removeServiceUser($server, $username);
  125. ////                                }
  126. ////                            }else{
  127. ////                                $this->removeServiceUser($server, $username);
  128. ////                            }
  129. ////
  130. ////
  131. ////
  132. ////
  133. ////
  134. ////                        }
  135. ////                    } catch (Exception $exception) {
  136. ////                        // Log the exception without affecting the entire transaction
  137. //////                        $this->telegram->exception($exception);
  138. ////                        $notificationService->exception($exception);
  139. ////                    }
  140. ////                }
  141. ////
  142. ////                // Commit the current transaction for the batch
  143. ////                $entityManager->flush();
  144. ////                $entityManager->commit();
  145. ////
  146. ////                // Clear the entity manager to free up memory
  147. ////                $entityManager->clear();
  148. ////
  149. ////            } catch (Exception $e) {
  150. ////                // Catch any exception and log it
  151. //////                $this->telegram->exception($e);
  152. ////$notificationService->exception($e);
  153. ////                // If EntityManager is closed due to an error, reset it
  154. ////                if (!$entityManager->isOpen()) {
  155. ////                    $entityManager = $this->getDoctrine()->getManager();
  156. ////                }
  157. ////            } finally {
  158. ////                // Clear the entity manager to free up memory after each batch
  159. ////                $entityManager->clear();
  160. ////            }
  161. ////        }
  162. ////
  163. ////        // Stop the stopwatch and get the event duration
  164. ////        $event = $stopwatch->stop('duration');
  165. ////
  166. ////        // Get elapsed time in milliseconds
  167. ////        $duration = $event->getDuration();  // Time in milliseconds
  168. //////        $this->telegram->sendRawMessage(
  169. //////            'Duration : '. $duration .' ms'.PHP_EOL.
  170. //////            'Ip : '. $ip .PHP_EOL.
  171. //////            'Users Trafical : '. count($users).PHP_EOL.
  172. //////            'Total Users : '.$usersCount
  173. //////
  174. //////        );
  175. ////        return new JsonResponse('Success', JsonResponse::HTTP_OK);
  176. ////
  177. ////
  178. ////    }
  179. //
  180. //
  181. //
  182. //
  183. //    #[Route('/client/marzban', name: 'app_client_marzban')]
  184. //    public function index(
  185. //        Request $request,
  186. //        ServiceRepository $serviceRepository,
  187. //        ServerRepository $serverRepository,
  188. //        NotificationService $notificationService
  189. //    ): JsonResponse
  190. //    {
  191. //        $now = new DateTime();
  192. //        $data = json_decode($request->getContent(), true);
  193. //        if (json_last_error() !== JSON_ERROR_NONE || !isset($data['ip'], $data['list'])) {
  194. //            return new JsonResponse('Invalid JSON or missing data', JsonResponse::HTTP_BAD_REQUEST);
  195. //        }
  196. //        sleep(random_int(100, 500));
  197. //        $users = $data['list'];
  198. //        $usersCount = count($users);
  199. //        $ip = $data['ip'];
  200. //        $totalServerUsage = array_reduce($users, function ($carry, $user) {
  201. //            return $carry + ($user['used_traffic'] ?? 0);
  202. //        }, 0);
  203. //
  204. //        $analytics = new ServersAnalyticsUsageService($ip, $this->entityManager);
  205. //        $analytics->addServerUsage($ip, $totalServerUsage);
  206. //        $server = $this->getServer($ip, $serverRepository);
  207. //        if (!$server) {
  208. //            $this->telegram->sendRawMessage(
  209. //                'این سرور داره کار میکنه ولی تو پنل نیست که بشه حجم به سرویس ها اضافه بشه : '.
  210. //                $ip);
  211. ////            return new JsonResponse('Server not found', JsonResponse::HTTP_BAD_REQUEST);
  212. //        }
  213. //
  214. //        $server?->setLastScriptUpdate(new \DateTimeImmutable());
  215. //        $this->ensureEntityManagerOpen();
  216. //        $this->flush();
  217. //
  218. //        $arrayData = array_chunk($users, 50);
  219. //        foreach ($arrayData as $arrayDatum) {
  220. //            try {
  221. //                $this->ensureEntityManagerOpen();
  222. //                $this->entityManager->beginTransaction();
  223. //
  224. //                foreach ($arrayDatum as $userArray) {
  225. //                    try {
  226. //                        $username = $userArray['username'];
  227. //                        $usedTraffic = ($userArray['used_traffic'] ?? 0);
  228. ////                        $calculationVolume = 1.2;
  229. //                        $calculationVolume = 2;
  230. //                        if ($server->getCountry()->getCode() === 'ir') {
  231. //                            $calculationVolume = 2;
  232. //                        }
  233. //
  234. //                        foreach ($server->getProtocols() as $protocol) {
  235. //                            if ($protocol->getCountry()?->getCode() === 'ir') {
  236. //                                $calculationVolume = 2;
  237. //                            }
  238. //                        }
  239. //
  240. //                        $usedTraffic *= $calculationVolume;
  241. //
  242. //                        if ($usedTraffic > 0) {
  243. //                            $service = $this->findService($username, $serviceRepository);
  244. //                            if ($service) {
  245. //                                $this->handleServiceUsage($server, $service, $usedTraffic);
  246. //                                if (!$service->getExpireAt()) {
  247. //                                    $expiredAt = (new \DateTimeImmutable())->add(new \DateInterval("P{$service->getPlan()->getDays()}D"));
  248. //                                    $service->setExpireAt($expiredAt);
  249. //                                    $this->ensureEntityManagerOpen();
  250. //                                    $this->flush();
  251. //                                }
  252. //                                if ($service->getPlan()->getServiceType() === 'unlimited' &&
  253. //                                    $service->getCountry() !== $server->getCountry()->getCode()) {
  254. //                                    $this->removeServiceUser($server, $username);
  255. //                                }
  256. //                            } else {
  257. //                                $this->removeServiceUser($server, $username);
  258. //                            }
  259. //                        }
  260. //
  261. //                    } catch (Exception $exception) {
  262. //                        $notificationService->exception($exception);
  263. //                    }
  264. //                }
  265. //
  266. //                $this->ensureEntityManagerOpen();
  267. //                $this->flush();
  268. //                $this->entityManager->commit();
  269. //
  270. //            } catch (Exception $e) {
  271. //                $notificationService->exception($e);
  272. //                if (!$this->entityManager->isOpen()) {
  273. //                    $this->entityManager = $this->getDoctrine()->getManager();
  274. //                }
  275. //            } finally {
  276. //                $this->ensureEntityManagerOpen();
  277. //                $this->entityManager->clear();
  278. //            }
  279. //        }
  280. //        return new JsonResponse('Success', JsonResponse::HTTP_OK);
  281. //    }
  282. //
  283. //
  284. //    private function getServer(
  285. //        string           $ip,
  286. //        ServerRepository $v2rayMultiServerRepository,
  287. //    ): Server|null
  288. //    {
  289. //        return $v2rayMultiServerRepository->findOneBy(['ip' => $ip, 'active' => 1, 'deletedAt' => null]);
  290. //    }
  291. //
  292. //    private function findService(
  293. //        string            $username,
  294. //        ServiceRepository $v2rayMultiServiceRepository,
  295. //    ): Service|null
  296. //    {
  297. //        return $v2rayMultiServiceRepository->findOneBy(['clientId' => $username]);
  298. //    }
  299. //
  300. //    private function handleServiceUsage(Server $server, Service $service, int $usedTraffic): void
  301. //    {
  302. //        if ($usedTraffic > 0) {
  303. //            $trafficToAdd = $usedTraffic;
  304. //            $service->setV2rayUsage($service->getV2rayUsage() + $trafficToAdd);
  305. //            $now = new \DateTime();
  306. //            $todayUsageObject = $this->serviceUsageRepository->findOneBy(['service' => $service , 'date' => $now]);
  307. //            if (!$todayUsageObject) {
  308. //                $todayUsageObject = new ServiceUsage();
  309. //                $todayUsageObject->setService($service);
  310. //                $todayUsageObject->setDate(new \DateTime());
  311. //                $this->entityManager->persist($todayUsageObject);
  312. //            }
  313. //            $todayUsageObject->setV2rayUsage(
  314. //                $todayUsageObject->getV2rayUsage() +
  315. //                (int)$trafficToAdd
  316. //            );
  317. //
  318. ////            TODO : check
  319. //
  320. ////            $this->entityManager->flush();
  321. //            if ((!$service->isEnabled() || !$service->isActive())) {
  322. //                $this->removeServiceUser($server, $service);
  323. //            }
  324. //
  325. //        }
  326. //    }
  327. //
  328. //
  329. //    private function removeServiceUser(Server $server, $service): void
  330. //    {
  331. //        $apiObject = new MarzbanNewAPI($server);
  332. //        if ($service instanceof Service){
  333. //            $apiObject->removeUser($service->getClientId());
  334. //        }else{
  335. //            $apiObject->removeUser($service);
  336. //        }
  337. //    }
  338. //
  339. //    private function ensureEntityManagerOpen(): void
  340. //    {
  341. //        if (!$this->entityManager->isOpen()) {
  342. //            $this->entityManager = $this->getDoctrine()->getManager();
  343. //        }
  344. //    }
  345. //
  346. //
  347. //    public function flush()
  348. //    {
  349. //        try {
  350. //            $this->entityManager->flush();
  351. //        } catch (\Doctrine\DBAL\Exception\UniqueConstraintViolationException $e) {
  352. //            $this->logDoctrineException($e);
  353. //            $this->resetEntityManager(); // 👈 این مهمه
  354. //        } catch (\Doctrine\DBAL\Exception\ConstraintViolationException $e) {
  355. //            $this->logDoctrineException($e);
  356. //            $this->resetEntityManager();
  357. //        } catch (\Doctrine\ORM\ORMException $e) {
  358. //            $this->logDoctrineException($e);
  359. //            $this->resetEntityManager();
  360. //        } catch (\Exception $e) {
  361. //            $this->logDoctrineException($e);
  362. //            $this->resetEntityManager();
  363. //        }
  364. //    }
  365. //
  366. //    private function logDoctrineException(\Exception $e): void
  367. //    {
  368. //        $this->telegram->sendRawMessage(
  369. //            "❌ Doctrine Error: " . $e->getMessage() . "\n\n" .
  370. //            "File: " . $e->getFile() . "\nLine: " . $e->getLine() . "\n\n" .
  371. //            "Trace:\n" . substr($e->getTraceAsString(), 0, 1000)
  372. //        );
  373. //    }
  374. //
  375. //    private function resetEntityManager(): void
  376. //    {
  377. //        if (!$this->entityManager->isOpen()) {
  378. //            $this->entityManager = $this->getDoctrine()->getManager();
  379. //        }
  380. //    }
  381. //
  382. //}
  383. class MarzbanController extends AbstractController
  384. {
  385.     private Telegram $telegram;
  386.     private EntityManagerInterface $entityManager;
  387.     private ServiceUsageRepository $serviceUsageRepository;
  389.     public function __construct(Telegram $telegram, EntityManagerInterface $entityManager, ServiceUsageRepository $serviceUsageRepository)
  390.     {
  391.         $this->telegram = $telegram;
  392.         $this->entityManager = $entityManager;
  393.         $this->serviceUsageRepository = $serviceUsageRepository;
  394.     }
  396.     #[Route('/client/marzban', name: 'app_client_marzban')]
  397.     public function index(Request $request, ServiceRepository $serviceRepository, ServerRepository $serverRepository, NotificationService $notificationService): JsonResponse
  398.     {
  399.         $data = json_decode($request->getContent(), true);
  400.         if (json_last_error() !== JSON_ERROR_NONE || !isset($data['ip'], $data['list'])) {
  401.             return new JsonResponse('Invalid JSON or missing data', JsonResponse::HTTP_BAD_REQUEST);
  402.         }
  404.         sleep(random_int(100, 500));
  405.         $users = $data['list'];
  406.         $ip = $data['ip'];
  408.         $totalServerUsage = array_reduce($users, fn($carry, $user) => $carry + ($user['used_traffic'] ?? 0), 0);
  409.         $analytics = new ServersAnalyticsUsageService($ip, $this->entityManager);
  410.         $analytics->addServerUsage($ip, $totalServerUsage);
  412.         $server = $this->getServer($ip, $serverRepository);
  413.         if (!$server) {
  414.             $this->telegram->sendRawMessage("سرور پیدا نشد: $ip");
  415.         }
  417.         $server?->setLastScriptUpdate(new \DateTimeImmutable());
  418.         $this->safeFlush();
  420.         foreach (array_chunk($users, 50) as $batch) {
  421.             try {
  422.                 $this->ensureEntityManagerOpen();
  423.                 $this->entityManager->beginTransaction();
  425.                 foreach ($batch as $user) {
  426.                     try {
  427.                         $username = $user['username'] ?? null;
  428.                         $usedTraffic = ($user['used_traffic'] ?? 0) * 2;
  430.                         if ($usedTraffic <= 0 || !$username) continue;
  432.                         $service = $this->findService($username, $serviceRepository);
  433.                         if ($service) {
  434.                             $this->handleServiceUsage($server, $service, $usedTraffic);
  436.                             if (!$service->getExpireAt()) {
  437.                                 $expiredAt = (new \DateTimeImmutable())->add(new \DateInterval("P{$service->getPlan()->getDays()}D"));
  438.                                 $service->setExpireAt($expiredAt);
  439.                                 $this->safeFlush();
  440.                             }
  442.                             if ($service->getPlan()->getServiceType() === 'unlimited' && $service->getCountry() !== $server->getCountry()->getCode()) {
  443.                                 $this->removeServiceUser($server, $username);
  444.                             }
  445.                         } else {
  446.                             $this->removeServiceUser($server, $username);
  447.                         }
  448.                     } catch (Exception $e) {
  449.                         $notificationService->exception($e);
  450.                     }
  451.                 }
  453.                 $this->safeFlush();
  454.                 if ($this->entityManager->getConnection()->isTransactionActive()) {
  455.                     $this->entityManager->commit();
  456.                 }
  458.             } catch (Exception $e) {
  459.                 $notificationService->exception($e);
  460.                 if ($this->entityManager->getConnection()->isTransactionActive()) {
  461.                     $this->entityManager->rollback();
  462.                 }
  463.                 $this->resetEntityManager();
  464.             } finally {
  465.                 $this->entityManager->clear();
  466.             }
  467.         }
  469.         return new JsonResponse('Success', JsonResponse::HTTP_OK);
  470.     }
  472.     private function getServer(string $ip, ServerRepository $repo): ?Server
  473.     {
  474.         return $repo->findOneBy(['ip' => $ip, 'active' => 1, 'deletedAt' => null]);
  475.     }
  477.     private function findService(string $username, ServiceRepository $repo): ?Service
  478.     {
  479.         return $repo->findOneBy(['clientId' => $username]);
  480.     }
  482.     private function handleServiceUsage(Server $server, Service $service, int $usedTraffic): void
  483.     {
  484.         $service->setV2rayUsage($service->getV2rayUsage() + $usedTraffic);
  485.         $today = new \DateTime();
  486.         $usage = $this->serviceUsageRepository->findOneBy(['service' => $service, 'date' => $today]);
  488.         if (!$usage) {
  489.             $usage = new ServiceUsage();
  490.             $usage->setService($service);
  491.             $usage->setDate($today);
  492.             $this->entityManager->persist($usage);
  493.         }
  495.         $usage->setV2rayUsage($usage->getV2rayUsage() + $usedTraffic);
  497.         if (!$service->isEnabled() || !$service->isActive()) {
  498.             $this->removeServiceUser($server, $service);
  499.         }
  500.     }
  502.     private function removeServiceUser(Server $server, $service): void
  503.     {
  504.         $api = new MarzbanNewAPI($server);
  505.         $clientId = $service instanceof Service ? $service->getClientId() : $service;
  506.         $api->removeUser($clientId);
  507.     }
  509.     private function ensureEntityManagerOpen(): void
  510.     {
  511.         if (!$this->entityManager->isOpen()) {
  512.             $this->resetEntityManager();
  513.         }
  514.     }
  516.     private function safeFlush(): void
  517.     {
  518.         try {
  519.             $this->entityManager->flush();
  520.         } catch (\Throwable $e) {
  521.             $this->logDoctrineException($e);
  522.             if ($this->entityManager->getConnection()->isTransactionActive()) {
  523.                 $this->entityManager->rollback();
  524.             }
  525.             $this->resetEntityManager();
  526.         }
  527.     }
  529.     private function resetEntityManager(): void
  530.     {
  531.         if (!$this->entityManager->isOpen()) {
  532.             $this->entityManager = $this->getDoctrine()->getManager();
  533.         }
  534.     }
  536.     private function logDoctrineException(\Throwable $e): void
  537.     {
  538.         $this->telegram->sendRawMessage(
  539.             "🚨 Doctrine Exception 🚨\n" .
  540.             "📛 Message: " . $e->getMessage() . "\n" .
  541.             "📁 File: " . $e->getFile() . "\n" .
  542.             "📍 Line: " . $e->getLine() . "\n" .
  543.             "🧵 Trace: " . substr($e->getTraceAsString(), 0, 2000)
  544.         );
  545.     }
  546. }