src/Controller/EngineController.php line 752

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  6. use Symfony\Component\HttpFoundation\Response;
  7. use Symfony\Component\HttpFoundation\JsonResponse;
  8. use Symfony\Component\Routing\Annotation\Route;
  9. use Symfony\Component\HttpFoundation\Request;
  10. use Doctrine\ODM\MongoDB\DocumentManager;
  11. use App\Document\Order;
  12. use App\Document\MarketOrder;
  13. use App\Document\Currencies;
  14. use App\Document\Wallet;
  15. use App\Document\Trade;
  16. use App\Document\Price;
  17. use App\Document\User;
  18. use Symfony\Contracts\Translation\TranslatorInterface;
  19. use App\Document\Setting;
  20. use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
  21. use Symfony\Component\Process\Exception\ProcessFailedException;
  22. use Symfony\Component\Process\Process;
  23. use KuCoin\SDK\Auth;
  24. use KuCoin\SDK\Http\SwooleHttp;
  25. use KuCoin\SDK\KuCoinApi;
  26. use KuCoin\SDK\PrivateApi\Order as KuCoinOrder;
  27. use KuCoin\SDK\PrivateApi\Account;
  28. use ccxt\coinex;
  33. class EngineController extends AbstractController
  34. {
  35.     private $translator;
  36.     private $doc;
  38.     public function __construct(TranslatorInterface $translator, DocumentManager $doctrine)
  39.     {
  40.         $this->translator = $translator;
  41.         $this->doc = $doctrine;
  42.     }
  44.     private function getLastPrice($crypto,$type='SELL'): float
  45.     {
  48.         $trade = $this->doc->createQueryBuilder(Price::class)
  49.             ->field('pair')->equals($crypto)
  50.             ->field('type')->equals($type)
  51.             ->getQuery()
  52.             ->getSingleResult();
  54.         return is_null($trade) ? 0 : $trade->getPrice() ;
  55.     }
  59. private function submitLimitOrder($doctrine, $data, $crypto, $userId, $user_limit_price, $wallet_rial, $wallet_crypto, $wallet_rial_balance, $wallet_crypto_balance, $last_usdt_price, $side): array
  60. {
  61.       $key = "8B830428825B4E8B9EF8483FB704FF62";
  62.         $secret = "3BC71E2BE239C53AB91DCA3019FFD6195AB41B072DF7C571" ;
  63.     $amount = $data->amount ?? null;
  64.     $price = $data->price ?? null;
  66.     if ($crypto === "USDT") {
  67.         return [
  68.             "status" => "400",
  69.             "msg" => 'این نوع برای usdt  فعال نمی باشد'
  70.         ];
  71.     }
  73.     if ($price <= 0) {
  74.         $translated = $this->translator->trans('Fill price');
  75.         return [
  76.             "status" => "400",
  77.             "msg" => $translated
  78.         ];
  79.     }
  81.     try {
  82.         $exchange = new \ccxt\coinex([
  83.             'apiKey' => $key,
  84.             'secret' => $secret,
  85.         ]);
  87.         $symbol = $crypto . '/USDT';
  88.         $params = ["createMarketBuyOrderRequiresPrice" => true];
  90.         $price_now = $exchange->fetchTicker($symbol)['last'];
  91.         $cost = $amount;
  93.         $deviation = abs($user_limit_price - $price_now) / $price_now * 100;
  94.         if ($deviation > 20) {
  95.             $suggested_price = round($price_now, 4);
  96.             $translated = $this->translator->trans(
  97.                 'Your price is too far from the market. Suggested price: ' . $suggested_price
  98.             );
  99.             return [
  100.                 "status" => "400",
  101.                 "msg" => $translated
  102.             ];
  103.         }
  105.         if ($side === 'buy') {
  106.             $cost = $amount * $price_now;
  107.         }
  109.         $order = $exchange->createOrder($symbol, 'limit', $side, $cost, $user_limit_price, $params);
  110.         $dealFunds = $order['cost'];
  111.         $fee_usdt = $order['fee']['cost'] ?? 0;
  112.         $fee = $fee_usdt * $last_usdt_price;
  113.         $total = $dealFunds * $last_usdt_price;
  115.         if ($side === 'buy') {
  116.             $wallet_rial->setballance($wallet_rial_balance - $total - $fee);
  117.             $wallet_crypto->setballance($wallet_crypto_balance + $amount);
  118.         } elseif ($side === 'sell') {
  119.             $wallet_rial->setballance($wallet_rial_balance + $total - $fee);
  120.             $wallet_crypto->setballance($wallet_crypto_balance - $amount);
  121.         }
  123.         $doctrine->flush();
  125.         return [
  126.             "status" => "200",
  127.             "msg" => "Order submitted",
  128.             "order_id" => $order,
  129.             "order_status" => "PENDING",
  130.             "fee" => $fee,
  131.             "price" => $user_limit_price
  132.         ];
  133.     } catch (\Exception $e) {
  134.         return [
  135.             "status" => "400",
  136.             "msg" => "ERROR",
  137.             "e" => $e->getMessage()
  138.         ];
  139.     }
  140. }
  144.     #[Route('/api/order/marketsubmit', methods: ['POST'], name: 'order_marketsubmit')]
  145.     public function marketSubmit(Request $request): JsonResponse
  146.     {
  147.         $data = json_decode($request->getContent(), false);
  148.         $user = $this->getUser();
  149.         $user_id = $user->getId();
  150.         $status = $user->getStatus();
  151.         
  152.         
  153.         
  154.         $market_symbol = $data->market ;
  156.         if ($status < 1) {
  157.             $translated = $this->translator->trans('your account not active');
  158.             return new JsonResponse(['status' => '400', 'msg' => $translated]);
  159.         }
  161.         $setting = $this->doc->createQueryBuilder(Setting::class)
  162.             ->limit(1)
  163.             ->getQuery()
  164.             ->getSingleResult();
  166.         $amount = floatval($data->amount);
  167.         $side = $data->side;
  168.         $type = $data->type;
  169.         $crypto = $data->crypto;
  170.         $price = isset($data->price) ? $data->price : 0;
  171.         
  172.         $user_limit_price = isset($data->price) ? $data->price : 0 ;
  173.         
  175.         if ($amount <= 0) {
  176.             $translated = $this->translator->trans('amount must larger than 1');
  177.             return new JsonResponse(['status' => '400', 'msg' => $translated]);
  178.         }
  184.         $wallet_rial = $this->doc->createQueryBuilder(Wallet::class)
  185.             ->field('userid')->equals($user_id)
  186.             ->field('pair')->equals($market_symbol)
  187.             ->getQuery()
  188.             ->getSingleResult();
  190.         $wallet_crypto = $this->doc->createQueryBuilder(Wallet::class)
  191.             ->field('userid')->equals($user_id)
  192.             ->field('pair')->equals($crypto)
  193.             ->getQuery()
  194.             ->getSingleResult();
  196.         $usdt_buy_price = $setting->getUsdtpricebuy();
  197.         $usdt_sell_price = $setting->getUsdtpricesell();
  199.         if ($side === 'sell' && $amount > $wallet_crypto->getballance()) {
  200.             $translated = $this->translator->trans('ballance is LOw');
  201.             return new JsonResponse(['status' => '400', 'msg' => $translated]);
  202.         }
  204.         $crypto_buy = $this->getLastPrice($crypto);
  205.         
  206.         $real_price_now =  $this->getLastPrice($crypto); 
  207.         
  208.         $crypto_buy += (($crypto_buy * 0.1) / 100);
  209.         
  210.         if($market_symbol === "RIAL") {
  211.              $crypto_price_buy = $crypto_buy * $usdt_buy_price ;
  212.         }else {
  213.         $crypto_price_buy = $crypto_buy ;
  214. }
  216.   if ($type === 'limit') {
  217.     if ($price <= 0) {
  218.         $translated = $this->translator->trans('Price is too low');
  219.         return new JsonResponse(['status' => '400', 'msg' => $translated]);
  220.     }
  222.     $priceDifference = abs(($price - $real_price_now) / $real_price_now) * 100;
  224.     if ($priceDifference > 20) {
  225.         $translated = $this->translator->trans('Price must be within ±20% of market price');
  226.         return new JsonResponse(['status' => '400', 'msg' => $translated  , 's' => $crypto_price_buy]);
  227.     }
  228. }
  231.         // if ($type === 'limit' && !$this->isPriceWithinRange($crypto_buy, $price)) {
  232.         //     $translated = $this->translator->trans('price not correct');
  233.         //     return new JsonResponse(['status' => '400', 'msg' => $translated]);
  234.         // }
  236.         if ($type === 'market') {
  237.               
  238.            
  239.             
  240.             $price = $crypto_buy;
  241.         }
  243.         if ($side === 'buy' && ($amount * $crypto_price_buy) >= $wallet_rial->getballance()) {
  244.             $translated = $this->translator->trans('ballance is LOw');
  245.             return new JsonResponse(['status' => '400', 'msg' => $translated]);
  246.         }
  248. if ($type === 'limit') {
  250.         // Freeze funds
  251.         if ($side === 'buy') {
  252.             $wallet_rial->setballance($wallet_rial->getballance() - ($amount * $crypto_price_buy));
  253.             $wallet_rial->setFrozen(($amount * $crypto_price_buy) + $wallet_rial->getFrozen());
  254.         } else {
  255.             $wallet_crypto->setballance($wallet_crypto->getballance() - $amount);
  256.             $wallet_crypto->setFrozen($amount + $wallet_crypto->getFrozen());
  257.             
  258.         }
  259.         
  260.         
  261.         
  262.             
  263.         
  264.         
  265.         $this->doc->persist($wallet_rial);
  266.         $this->doc->persist($wallet_crypto);
  267.         $this->doc->flush();
  268.         
  269. }
  270.         
  274.               
  275.         $key = "8B830428825B4E8B9EF8483FB704FF62";
  276.         $secret = "3BC71E2BE239C53AB91DCA3019FFD6195AB41B072DF7C571" ;
  279.         if ($type === 'market') {
  283. try {
  284.     // Set up your CoinEx API credentials
  285.     $api_key = $key;
  286.     $api_secret = $secret;
  288.     // Instantiate the CoinEx exchange class
  289.     $exchange = new coinex([
  290.         'apiKey' => $api_key,
  291.         'secret' => $api_secret,
  292.     ]);
  294.     // Define the trading pair and order details
  295.     $symbol = $crypto . '/USDT';  // Market pair
  297.     $params = ["createMarketBuyOrderRequiresPrice" => false];
  298.     $cost = $amount;
  299.     $price_now = $exchange->fetchTicker($symbol)['last'];
  301.     if ($side === 'buy') {
  302.         $cost = $amount * $price_now;
  303.     }
  305.     try {
  306.         $api_order = $exchange->createOrder($symbol, 'market', $side, $cost, 0, $params);
  307.         $order_submited = true;
  308.         
  309.         
  311.         
  312.         
  314.     } catch (\ccxt\NetworkError $e) {
  315.         return new JsonResponse([
  316.             "status" => "400",
  317.             "msg" => "Network Error"
  318.         ]);
  320.     } catch (\ccxt\ExchangeError $e) {
  321.         return new JsonResponse([
  322.             "status" => "400",
  323.             "msg" => $e->getMessage()
  324.         ]);
  326.     } catch (Exception $e) {
  327.         return new JsonResponse([
  328.             "status" => "400",
  329.             "msg" => $e->getMessage()
  330.         ]);
  331.     }
  333. } catch (Exception $e) {
  334.     return new JsonResponse([
  335.         "status" => "400",
  336.         "msg" => $e->getMessage()
  337.     ]);
  338. }
  344.             $robot_id = '666621eea320d65e3f6878ec';
  345.             $buy_user_id = $side === 'buy' ? $user_id : $robot_id;
  346.             $sell_user_id = $side === 'sell' ? $user_id : $robot_id;
  348.            $this->updateWallets($buy_user_id, $sell_user_id, $amount, $crypto, $price , $market_symbol);
  352.         } else {
  353.             
  354.             if ($type === 'limit') {
  355.     $result = $this->submitLimitOrder(
  356.         $this->doc,
  357.         $data,
  358.         $crypto,
  359.         $user_id,
  360.         $user_limit_price,
  361.         $wallet_rial,
  362.         $wallet_crypto,
  363.         $wallet_rial->getballance(),
  364.         $wallet_crypto->getballance(),
  365.         $usdt_buy_price,
  366.         $side
  367.     );
  370.     $api_order = $result['order_id'];
  371.  
  373.    
  374. }
  376.         }
  377.         
  378.         
  379.         
  380.         $order = new MarketOrder();
  381.         $order->setUserid($user_id);
  382.         $order->setAmount($amount);
  383.         $order->setPair($crypto);
  384.         $order->setSide($side);
  385.         $order->setType($type);
  386.         $order->setPrice($price);
  387.         $order->setTakeprofit("0");
  388.         $order->setStoploss("0");
  389.         $order->setTime(time());
  390.         $order->setFee(0);
  391.         $order->setApi(json_encode($api_order));
  392.         $order->setStatus("Pending");
  394.         $this->doc->persist($order);
  395.         $this->doc->flush();
  397.         $translated = $this->translator->trans('Order Submited');
  398.         return new JsonResponse(['status' => '200', 'msg' => $translated]);
  399.     }
  402. //     #[Route('/api/order/marketsubmit', methods: ['POST'], name: 'order_marketsubmit')]
  403. //     public function marketSubmit(Request $request): JsonResponse
  404. //     {
  405. //         $data = json_decode($request->getContent(), false);
  406. //         $user = $this->getUser();
  407. //         $user_id = $user->getId();
  408. //         $status = $user->getStatus();
  409.         
  410.         
  411.         
  412. //         $market_symbol = $data->market ;
  414. //         if ($status < 1) {
  415. //             $translated = $this->translator->trans('your account not active');
  416. //             return new JsonResponse(['status' => '400', 'msg' => $translated]);
  417. //         }
  419. //         $setting = $this->doc->createQueryBuilder(Setting::class)
  420. //             ->limit(1)
  421. //             ->getQuery()
  422. //             ->getSingleResult();
  424. //         $amount = floatval($data->amount);
  425. //         $side = $data->side;
  426. //         $type = $data->type;
  427. //         $crypto = $data->crypto;
  428. //         $price = isset($data->price) ? $data->price : 0;
  430. //         if ($amount <= 0) {
  431. //             $translated = $this->translator->trans('amount must larger than 1');
  432. //             return new JsonResponse(['status' => '400', 'msg' => $translated]);
  433. //         }
  439. //         $wallet_rial = $this->doc->createQueryBuilder(Wallet::class)
  440. //             ->field('userid')->equals($user_id)
  441. //             ->field('pair')->equals($market_symbol)
  442. //             ->getQuery()
  443. //             ->getSingleResult();
  445. //         $wallet_crypto = $this->doc->createQueryBuilder(Wallet::class)
  446. //             ->field('userid')->equals($user_id)
  447. //             ->field('pair')->equals($crypto)
  448. //             ->getQuery()
  449. //             ->getSingleResult();
  451. //         $usdt_buy_price = $setting->getUsdtpricebuy();
  452. //         $usdt_sell_price = $setting->getUsdtpricesell();
  454. //         if ($side === 'sell' && $amount > $wallet_crypto->getballance()) {
  455. //             $translated = $this->translator->trans('ballance is LOw');
  456. //             return new JsonResponse(['status' => '400', 'msg' => $translated]);
  457. //         }
  459. //         $crypto_buy = $this->getLastPrice($crypto);
  460. //         $crypto_buy += (($crypto_buy * 0.1) / 100);
  461.         
  462. //         if($market_symbol === "RIAL") {
  463. //              $crypto_price_buy = $crypto_buy * $usdt_buy_price ;
  464. //         }else {
  465. //         $crypto_price_buy = $crypto_buy ;
  466. // }
  468. //         if ($type === 'limit' && $price <= 0) {
  469. //             $translated = $this->translator->trans('Price is Low');
  470. //             return new JsonResponse(['status' => '400', 'msg' => $translated]);
  471. //         }
  475. // $priceDifference = abs(($price - $crypto_price_buy) / $crypto_price_buy) * 100;
  477. // if ($type === 'limit' && ($price <= 0 || $priceDifference > 2)) {
  478. //     $translated = $this->translator->trans('Price must be within ±2% range');
  479. //     return new JsonResponse(['status' => '400', 'msg' => $translated]);
  480. // }
  483. //         // if ($type === 'limit' && !$this->isPriceWithinRange($crypto_buy, $price)) {
  484. //         //     $translated = $this->translator->trans('price not correct');
  485. //         //     return new JsonResponse(['status' => '400', 'msg' => $translated]);
  486. //         // }
  488. //         if ($type === 'market') {
  489.               
  490.            
  491.             
  492. //             $price = $crypto_buy;
  493. //         }
  495. //         if ($side === 'buy' && ($amount * $crypto_price_buy) >= $wallet_rial->getballance()) {
  496. //             $translated = $this->translator->trans('ballance is LOw');
  497. //             return new JsonResponse(['status' => '400', 'msg' => $translated]);
  498. //         }
  500. // if ($type === 'limit') {
  502. //         // Freeze funds
  503. //         if ($side === 'buy') {
  504. //             $wallet_rial->setballance($wallet_rial->getballance() - ($amount * $crypto_price_buy));
  505. //             $wallet_rial->setFrozen(($amount * $crypto_price_buy) + $wallet_rial->getFrozen());
  506. //         } else {
  507. //             $wallet_crypto->setballance($wallet_crypto->getballance() - $amount);
  508. //             $wallet_crypto->setFrozen($amount + $wallet_crypto->getFrozen());
  509.             
  510. //         }
  511.         
  512.         
  513.         
  514.             
  515.         
  516.         
  517. //         $this->doc->persist($wallet_rial);
  518. //         $this->doc->persist($wallet_crypto);
  519. //         $this->doc->flush();
  520.         
  521. // }
  522.         
  524. //         $order = new MarketOrder();
  525. //         $order->setUserid($user_id);
  526. //         $order->setAmount($amount);
  527. //         $order->setPair($crypto);
  528. //         $order->setSide($side);
  529. //         $order->setType($type);
  530. //         $order->setPrice($price);
  531. //         $order->setTakeprofit("0");
  532. //         $order->setStoploss("0");
  533. //         $order->setTime(time());
  534. //         $order->setFee(0);
  535. //         $order->setApi('');
  536. //         $order->setStatus("Pending");
  538. //         $this->doc->persist($order);
  539. //         $this->doc->flush();
  541. //         if ($type === 'market') {
  542. //             // Create an opposite order for the robot
  543. //             $robot_id = '666621eea320d65e3f6878ec';
  545. //             // Mark the original order as filled
  546. //             $order->setStatus('Filled');
  547. //             $this->doc->persist($order);
  548. //             $this->doc->flush();
  550. //             // Create a new trade
  551. //             $trade_id = \Ramsey\Uuid\Uuid::uuid4()->toString(); // Generate a unique trade ID
  552. //             $buy_user_id = $side === 'buy' ? $user_id : $robot_id;
  553. //             $sell_user_id = $side === 'sell' ? $user_id : $robot_id;
  554. //             $this->createNewTrade($buy_user_id, $sell_user_id, $amount, $crypto,'market', $price, $trade_id, 'Completed');
  556. //             // Update wallets
  557. //             $this->updateWallets($buy_user_id, $sell_user_id, $amount, $crypto, $price , $market_symbol);
  558. //         }
  560. //         $translated = $this->translator->trans('Order Submited');
  561. //         return new JsonResponse(['status' => '200', 'msg' => $translated]);
  562. //     }
  564. #[Route('/api/order/cancelmarketsubmit', methods: ['POST'], name: 'order_cancelmarketsubmit')]
  565. public function cancelMarketSubmit(Request $request): JsonResponse
  566. {
  567.     $data = json_decode($request->getContent(), false);
  568.     $user = $this->getUser();
  569.     $order_id = $data->id;
  571.     $order = $this->doc->createQueryBuilder(MarketOrder::class)
  572.         ->field('id')->equals($order_id)
  573.         ->getQuery()
  574.         ->getSingleResult();
  576.     if (!$order || $order->getStatus() !== 'Pending') {
  577.         return new JsonResponse(['status' => '400', 'msg' => 'Order not found or not cancelable']);
  578.     }
  580.     // CoinEx API cancel logic
  581.     $apiinfo = json_decode($order->getApi(), true);
  582.             $key = "8B830428825B4E8B9EF8483FB704FF62";
  583.         $secret = "3BC71E2BE239C53AB91DCA3019FFD6195AB41B072DF7C571" ;
  584.         
  586.     try {
  587.         $exchange = new \ccxt\coinex([
  588.             'apiKey' => $key,
  589.             'secret' => $secret,
  590.         ]);
  592.         $symbol = $order->getPair() . '/USDT';
  593.         $exchange->cancelOrder($apiinfo['id'], $symbol);
  595.     } catch (\ccxt\NetworkError | \ccxt\ExchangeError | \Exception $e) {
  596.         return new JsonResponse(['status' => '400', 'msg' => $e->getMessage()]);
  597.     }
  599.     // Update local order status
  600.     $this->doc->createQueryBuilder(MarketOrder::class)
  601.         ->field('id')->equals($order_id)
  602.         ->findAndUpdate()
  603.         ->field('status')->set('cancel')
  604.         ->getQuery()
  605.         ->execute();
  607.     // Unfreeze logic
  608.     $setting = $this->doc->createQueryBuilder(Setting::class)
  609.         ->limit(1)
  610.         ->getQuery()
  611.         ->getSingleResult();
  613.     $usdt_buy_price = $setting->getUsdtpricebuy();
  614.     $usdt_sell_price = $setting->getUsdtpricesell();
  616.     if ($order->getSide() === 'buy') {
  617.         $wallet_rial = $this->doc->createQueryBuilder(Wallet::class)
  618.             ->field('userid')->equals($user->getId())
  619.             ->field('pair')->equals("RIAL")
  620.             ->getQuery()
  621.             ->getSingleResult();
  622.         $this->unfreezeFunds($wallet_rial, $order->getAmount() * $order->getPrice() * $usdt_buy_price);
  623.     } else {
  624.         $wallet_crypto = $this->doc->createQueryBuilder(Wallet::class)
  625.             ->field('userid')->equals($user->getId())
  626.             ->field('pair')->equals($order->getPair())
  627.             ->getQuery()
  628.             ->getSingleResult();
  629.         $this->unfreezeFunds($wallet_crypto, $order->getAmount());
  630.     }
  632.     $translated = $this->translator->trans('Order Canceled');
  633.     return new JsonResponse(['status' => '200', 'msg' => $translated]);
  634. }
  637.     private function unfreezeFunds($wallet, $amount)
  638.     {
  639.         $wallet->setballance($wallet->getballance() + $amount);
  640.         $wallet->setFrozen($wallet->getFrozen() - $amount);
  641.         $this->doc->persist($wallet);
  642.         $this->doc->flush();
  643.     }
  645.     private function createNewTrade($buy_user_id, $sell_user_id, $amount, $pair , $type, $price, $trade_id, $status)
  646.     {
  647.         $trade = new Trade();
  648.         $trade->setAmount($amount);
  649.         $trade->setPair($pair);
  650.         $trade->setType($type);
  651.         $trade->setPrice($price);
  652.         $trade->setTime(time());
  653.         $trade->setStatus($status);
  654.         $trade->setFee(0);
  655.         $trade->setTradeid($trade_id);
  656.         $trade->setbuyUserid($buy_user_id);
  657.         $trade->setsellUserid($sell_user_id);
  658.         $this->doc->persist($trade);
  659.         $this->doc->flush();
  660.     }
  662.     private function createOrder($user_id, $amount, $pair, $side, $type, $price, $robot, $status)
  663.     {
  664.         $order = new MarketOrder();
  665.         $order->setUserid($user_id);
  666.         $order->setAmount($amount);
  667.         $order->setPair($pair);
  668.         $order->setSide($side);
  669.         $order->setType($type);
  670.         $order->setPrice($price);
  671.         $order->setTakeprofit("0");
  672.         $order->setStoploss("0");
  673.         $order->setTime(time());
  674.         $order->setFee(0);
  675.         $order->setRobot($robot);
  676.         $order->setStatus($status);
  677.         $this->doc->persist($order);
  678.         $this->doc->flush();
  679.     }
  681.     private function updateOrder($order)
  682.     {
  683.         $this->doc->persist($order);
  684.         $this->doc->flush();
  685.     }
  687.     private function updateWallets($buy_user_id, $sell_user_id, $amount, $pair, $price , $market_symbol)
  688.     {
  689.         $usdt_buy_price = $this->doc->createQueryBuilder(Setting::class)
  690.             ->limit(1)
  691.             ->getQuery()
  692.             ->getSingleResult()
  693.             ->getUsdtpricebuy();
  696.             if($market_symbol === "RIAL") {
  697.                 $rial_amount = $amount * $price * $usdt_buy_price;
  698.             } else {
  699.         $rial_amount = $amount * $price ;  // Corrected calculation of rial_amount
  700. }
  701.         // Update buyer's wallet
  702.         $this->addMoney($buy_user_id, $pair, $amount);
  703.         $this->removeMoney($buy_user_id, $market_symbol, $rial_amount);
  705.         // Update seller's wallet
  706.         $this->addMoney($sell_user_id, $market_symbol, $rial_amount);
  707.         $this->removeMoney($sell_user_id, $pair, $amount);
  708.     }
  710.     private function addMoney($user_id, $pair, $amount)
  711.     {
  712.         $wallet = $this->getWallet($user_id, $pair);
  713.         if ($wallet) {
  714.             $wallet->setballance($wallet->getballance() + $amount);
  715.             $this->updateWallet($wallet);
  716.         }
  717.     }
  719.     private function removeMoney($user_id, $pair, $amount)
  720.     {
  721.         $wallet = $this->getWallet($user_id, $pair);
  722.         if ($wallet) {
  723.             $wallet->setballance($wallet->getballance() - $amount);
  724.             $this->updateWallet($wallet);
  725.         }
  726.     }
  728.     private function getWallet($user_id, $pair)
  729.     {
  730.         return $this->doc->createQueryBuilder(Wallet::class)
  731.             ->field('userid')->equals($user_id)
  732.             ->field('pair')->equals($pair)
  733.             ->getQuery()
  734.             ->getSingleResult();
  735.     }
  737.     private function updateWallet($wallet)
  738.     {
  739.         $this->doc->persist($wallet);
  740.         $this->doc->flush();
  741.     }
  742.     
  743.     
  744.         private function isPriceWithinRange($lastPrice, $newPrice): bool
  745.         {
  746.         $minPrice = $lastPrice * 0.1;
  747.         $maxPrice = $lastPrice * 0.02;
  748.         return $newPrice >= $minPrice && $newPrice <= $maxPrice;
  749.     }
  750.     
  751.         #[Route('/pub/order/matchengine', methods: ['GET'], name: 'trade_matchengine')]
  752.         public function matchEngine(): JsonResponse
  753.         {
  754.     $pairs = ["BTC", "ETH", "DOGE", "ADA", "SOL", "DOT", "TRX", "BNB", "LTC"];
  756.     foreach ($pairs as $pair) {
  757.         // Retrieve all limit buy and sell orders
  758.         $buy_limit_orders = $this->getMarketOrderList($pair, 'buy', 'limit');
  759.         $sell_limit_orders = $this->getMarketOrderList($pair, 'sell', 'limit');
  761.         // Get the last price of the pair
  762.         $last_price_buy = round($this->getLastPrice($pair,'BUY'), 6);
  763.         
  764.         $last_price_sell = round($this->getLastPrice($pair), 6);
  765.         
  766.   
  768.         // Process buy limit orders
  769.         foreach ($buy_limit_orders as $buy_order) {
  770.             
  771.             if ($buy_order->getPrice() >= $last_price_buy) {
  772.                 $this->processMatchingOrder($buy_order, $buy_order->getPrice());
  773.             }
  774.         }
  776.         // Process sell limit orders
  777.         foreach ($sell_limit_orders as $sell_order) {
  778.             echo "o" . $sell_order->getPrice() . 'o' . $last_price_sell ;
  779.             if ($sell_order->getPrice() <= $last_price_sell) {
  780.                 $this->processMatchingOrder($sell_order, $sell_order->getPrice());
  781.             }
  782.         }
  783.     }
  785.     return new JsonResponse(['status' => '200', 'msg' => 'Match Engine Run Successfully']);
  786. }
  788.         private function processMatchingOrder($order, $last_price)
  789.         {
  790.     $user_id = $order->getUserid();
  791.     $amount = $order->getAmount();
  792.     $pair = $order->getPair();
  793.     $side = $order->getSide();
  794.     $opposite_side = $side === 'buy' ? 'sell' : 'buy';
  795.     $robot_id = '666621eea320d65e3f6878ec';
  797.     // Create an opposite order for the robot
  798.     $this->createOrder($robot_id, $amount, $pair, $opposite_side, 'market', $last_price, true, 'Filled');
  800.     // Mark the original order as filled
  801.     $order->setStatus('Filled');
  802.     $this->updateOrder($order);
  806.         $setting = $this->doc->createQueryBuilder(Setting::class)
  807.             ->limit(1)
  808.             ->getQuery()
  809.             ->getSingleResult();
  812.         $usdt_buy_price = $setting->getUsdtpricebuy();
  813.         $usdt_sell_price = $setting->getUsdtpricesell();
  816.         $crypto_price_buy = $this->getLastPrice($pair , 'BUY') ;
  817.         $crypto_price_sell = $this->getLastPrice($pair) ;
  818.         
  822.     // Create a new trade
  823.     $trade_id = \Ramsey\Uuid\Uuid::uuid4()->toString();
  824.     $buy_user_id = $side === 'buy' ? $user_id : $robot_id;
  825.     $sell_user_id = $side === 'sell' ? $user_id : $robot_id;
  826.     $this->createNewTrade($buy_user_id, $sell_user_id, $amount, $pair ,'limit', $last_price, $trade_id, 'Completed');
  827.     
  828.     
  829.               $wallet_rial = $this->doc->createQueryBuilder(Wallet::class)
  830.                     ->field('userid')->equals($user_id)
  831.                     ->field('pair')->equals("RIAL")
  832.                     ->getQuery()
  833.                     ->getSingleResult();
  834.                     
  835.                     
  836.             $wallet_crypto = $this->doc->createQueryBuilder(Wallet::class)
  837.                     ->field('userid')->equals($user_id)
  838.                     ->field('pair')->equals($order->getPair())
  839.                     ->getQuery()
  840.                     ->getSingleResult();
  841.     
  842.     
  843.                if ($order->getSide() === 'buy') {
  844.       
  845.                     
  846.                $wallet_rial->setFrozen(  $wallet_rial->getFrozen()  - (($amount * $crypto_price_buy) * $usdt_buy_price) );
  847.                $wallet_crypto->setballance($wallet_crypto->getballance() + $amount);
  849.                
  850.             } else {
  852.              
  853.                 $wallet_crypto->setFrozen( $wallet_crypto->getFrozen() - $amount);
  854.                 $wallet_rial->setballance($wallet_rial->getballance() + (($amount * $crypto_price_buy) * $usdt_buy_price));
  855.      
  856.    
  857.             }
  858.                  $this->updateWallet($wallet_rial);
  859.                 $this->updateWallet($wallet_crypto);
  861.     // Update wallets
  862.   //  $this->updateWallets($buy_user_id, $sell_user_id, $amount, $pair, $last_price);
  863. }
  864.     
  865.         private function getMarketOrderList($pair, $side, $type)
  866.         {
  867.         return $this->doc->createQueryBuilder(MarketOrder::class)
  868.             ->field('side')->equals($side)
  869.             ->field('type')->equals($type)
  870.             ->field('status')->equals('Pending')
  871.             ->field('pair')->equals($pair)
  872.          
  873.             ->limit(2000)
  874.             ->sort('time', 'asc')
  875.             ->getQuery()
  876.             ->execute();
  877.     }
  878.     
  879. }