src/UI/Admin/Controller/PaymentController.php line 36

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace App\UI\Admin\Controller;
  7. use App\Domain\Payment\Model\Payment;
  8. use App\UI\Admin\Datatable\PaymentDatatable;
  9. use App\UI\Shared\Controller\AbstractController;
  10. use Doctrine\Persistence\ManagerRegistry;
  11. use Sg\DatatablesBundle\Response\DatatableResponse;
  12. use Symfony\Component\HttpFoundation\Request;
  13. use Symfony\Component\HttpFoundation\Response;
  14. use Symfony\Component\HttpFoundation\StreamedResponse;
  15. use Symfony\Component\Routing\Annotation\Route;
  16. use Symfony\Component\HttpFoundation\JsonResponse;
  18. use Doctrine\DBAL\Connection;
  19. use Symfony\Component\HttpFoundation\ResponseHeaderBag;
  21. use Psr\Log\LoggerAwareInterface;
  22. use Psr\Log\LoggerAwareTrait;
  23. use App\Application\Common\CommonServices;
  24. use GuzzleHttp\Client;
  25. use GuzzleHttp\Exception\ClientException;
  26. use GuzzleHttp\Exception\GuzzleException;
  27. use GuzzleHttp\Exception\ServerException;
  28. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  30. #[Route('/payments')]
  31. class PaymentController extends AbstractController implements LoggerAwareInterface
  32. {
  33.     use LoggerAwareTrait;
  35.     #[Route(path: '/', name: 'admin_payments')]
  36.     public function index(
  37.         Request $request,
  38.         PaymentDatatable $datatable,
  39.         DatatableResponse $datatableResponse,
  40.         \Doctrine\Persistence\ManagerRegistry $doctrine,
  41.     ): Response {
  42.         $isAjax = $request->isXmlHttpRequest();
  44.         $datatable->buildDatatable();
  46.         if ($isAjax) {
  47.             try {
  48.                 // Log raw incoming params
  49.                 // $this->logger->info('Request query parameters', $request->query->all());
  51.                 $data = $request->query->all();
  52.                 $tzName = $request->query->get('tz') ?? \date_default_timezone_get() ?? 'UTC';
  54.                 // Validate/normalize user tz
  55.                 try {
  56.                     $userTz = new \DateTimeZone($tzName);
  57.                 } catch (\Throwable) {
  58.                     $tzName = 'UTC';
  59.                     $userTz = new \DateTimeZone('UTC');
  60.                 }
  61.                 // $this->logger->info('TIMEZONE', ['tz' => $tzName]);
  63.                 // -------- Detect DB session timezone (MySQL / Postgres) --------
  64.                 $conn = $doctrine->getConnection();
  65.                 $dbTzName = 'UTC';
  66.                 try {
  67.                     $platform = $conn->getDatabasePlatform()->getName();
  69.                     if ($platform === 'mysql') {
  70.                         $sessionTz = $conn->fetchOne('SELECT @@time_zone');
  71.                         if ($sessionTz === 'SYSTEM') {
  72.                             $systemTz = $conn->fetchOne('SELECT @@system_time_zone');
  73.                             $dbTzName = $systemTz ?: 'UTC';
  74.                         } else {
  75.                             $dbTzName = $sessionTz ?: 'UTC';
  76.                         }
  77.                     } elseif ($platform === 'postgresql') {
  78.                         // SHOW TIME ZONE returns a single row, single column
  79.                         $dbTzName = $conn->fetchOne('SHOW TIME ZONE') ?: 'UTC';
  80.                     }
  81.                 } catch (\Throwable $e) {
  82.                     // keep default 'UTC' on any failure
  83.                 }
  85.                 // Ensure it's a valid IANA/offset for PHP
  86.                 try {
  87.                     $dbTz = new \DateTimeZone($dbTzName);
  88.                 } catch (\Throwable) {
  89.                     $dbTzName = 'UTC';
  90.                     $dbTz = new \DateTimeZone('UTC');
  91.                 }
  93.                 // $this->logger->info('DB TIMEZONE', ['db_tz' => $dbTzName, 'platform' => $conn->getDatabasePlatform()->getName()]);
  95.                 // -------- Strip createdAt LIKE filter --------
  96.                 $createdAtRange = null;
  97.                 if (isset($data['columns'])) {
  98.                     foreach ($data['columns'] as &$column) {
  99.                         if (($column['data'] ?? null) === 'createdAt' && !empty($column['search']['value'])) {
  100.                             $createdAtRange = explode('|', $column['search']['value']);
  101.                             $column['search']['value'] = '';
  102.                             $column['searchable'] = 'false';
  103.                         }
  104.                     }
  105.                     unset($column);
  106.                 }
  108.                 // Overwrite cleaned query
  109.                 $request->query->replace($data);
  111.                 // -------- Build query --------
  112.                 $datatableResponse->setDatatable($datatable);
  113.                 $queryBuilder = $datatableResponse->getDatatableQueryBuilder()->getQb();
  114.                 $alias = $queryBuilder->getRootAliases()[0];
  116.                 // Always show latest records at the top
  117.                 $queryBuilder->addOrderBy("$alias.createdAt", "DESC");
  119.                 if ($createdAtRange && count($createdAtRange) === 2) {
  120.                     $startStr = \trim($createdAtRange[0]) . ' 00:00:00';
  121.                     $endStr = \trim($createdAtRange[1]) . ' 23:59:59';
  123.                     // Interpret the picked dates as *user-local calendar days*
  124.                     $startLocal = \DateTimeImmutable::createFromFormat('Y-m-d H:i:s', $startStr, $userTz);
  125.                     $endLocal = \DateTimeImmutable::createFromFormat('Y-m-d H:i:s', $endStr, $userTz);
  127.                     if (!$startLocal || !$endLocal) {
  128.                         throw new \RuntimeException('Invalid createdAt date range.');
  129.                     }
  131.                     // Convert to *DB session timezone* we detected above
  132.                     $startDb = $startLocal->setTimezone($dbTz);
  133.                     $endDb = $endLocal->setTimezone($dbTz);
  135.                     $queryBuilder
  136.                         ->andWhere("$alias.createdAt BETWEEN :start AND :end")
  137.                         ->setParameter('start', $startDb, 'datetime_immutable')
  138.                         ->setParameter('end', $endDb, 'datetime_immutable');
  140.                     $this->logger->info('createdAt filter applied', [
  141.                         'user_tz' => $tzName,
  142.                         'db_tz' => $dbTzName,
  143.                         'start_loc' => $startLocal->format('Y-m-d H:i:sP'),
  144.                         'end_loc' => $endLocal->format('Y-m-d H:i:sP'),
  145.                         'start_db' => $startDb->format('Y-m-d H:i:sP'),
  146.                         'end_db' => $endDb->format('Y-m-d H:i:sP'),
  147.                     ]);
  148.                 }
  150.                 // -------- Return DataTables JSON --------
  151.                 $response = $datatableResponse->getResponse();
  152.                 // $this->logger->info('Payment datatable request completed.', [
  153.                 //     'response' => json_decode($response->getContent(), true)
  154.                 // ]);
  156.                 return $response;
  157.             } catch (\Throwable $e) {
  158.                 return new JsonResponse([
  159.                     'error' => true,
  160.                     'message' => $e->getMessage(),
  161.                     'trace' => $e->getTraceAsString(),
  162.                 ]);
  163.             }
  164.         }
  166.         return $this->render('admin/payment/index.html.twig', [
  167.             'datatable' => $datatable,
  168.         ]);
  169.     }
  171.     private const REFUND_IN_PROGRESS_STATUSES = ['initiated', 'pending'];
  173.     #[Route(path: '/{id}/refund-details', name: 'admin_payments_refund_details', methods: ['GET'])]
  174.     public function refundDetails(Payment $payment, ManagerRegistry $doctrine): JsonResponse
  175.     {
  176.         $factoryName = $payment->getSite()?->getPaymentGatewayConfig()?->getFactoryName();
  178.         if ('dimoco_pay' !== $factoryName) {
  179.             return $this->createErrorJsonResponse('Refunds are only available for Dimoco Pay payments.');
  180.         }
  182.         $summary = $this->computeRefundSummary($payment, $doctrine->getConnection());
  184.         return new JsonResponse([
  185.             'success' => true,
  186.             'currency' => $payment->getCurrency(),
  187.             'pisp_status' => $payment->getPispStatus(),
  188.             'total_amount' => $summary['total_amount'],
  189.             'refunded_amount' => $summary['refunded_amount'],
  190.             'remaining_amount' => $summary['remaining_amount'],
  191.             'in_progress' => $summary['in_progress'],
  192.             'can_refund' => 'completed' === $payment->getPispStatus() && $summary['can_refund'],
  193.             'history' => $summary['history'],
  194.         ]);
  195.     }
  197.     /**
  198.      * @return array{
  199.      *     seed_row: ?array,
  200.      *     total_amount: float,
  201.      *     refunded_amount: float,
  202.      *     remaining_amount: float,
  203.      *     in_progress: bool,
  204.      *     can_refund: bool,
  205.      *     history: list<array{amount: float, reason: ?string, status: ?string, created_at: ?string}>,
  206.      * }
  207.      */
  208.     private function computeRefundSummary(Payment $payment, Connection $conn): array
  209.     {
  210.         $refundRows = $conn->fetchAllAssociative(
  211.             'SELECT * FROM refund_requests WHERE payment_id = :payment_id ORDER BY id ASC',
  212.             ['payment_id' => (string) $payment->getId()]
  213.         );
  215.         // The first row is seeded at purchase time and carries session_id/reference_debit_id;
  216.         // every subsequent row (status not null) is one actual refund attempt.
  217.         $seedRow = $refundRows[0] ?? null;
  219.         $inProgress = false;
  220.         $refunded = 0.0;
  221.         $history = [];
  223.         foreach ($refundRows as $row) {
  224.             if (null === $row['status']) {
  225.                 continue;
  226.             }
  228.             if (in_array($row['status'], self::REFUND_IN_PROGRESS_STATUSES, true)) {
  229.                 $inProgress = true;
  230.             }
  232.             if ('completed' === $row['status']) {
  233.                 $refunded += (float) $row['amount'];
  234.             }
  236.             $history[] = [
  237.                 'amount' => (float) $row['amount'],
  238.                 'reason' => $row['reason'],
  239.                 'status' => $row['status'],
  240.                 'created_at' => $row['created_at'],
  241.             ];
  242.         }
  244.         $totalAmount = $payment->getAmount() / 100;
  245.         $remaining = round($totalAmount - $refunded, 2);
  247.         return [
  248.             'seed_row' => $seedRow,
  249.             'total_amount' => $totalAmount,
  250.             'refunded_amount' => round($refunded, 2),
  251.             'remaining_amount' => $remaining,
  252.             'in_progress' => $inProgress,
  253.             'can_refund' => !$inProgress && $remaining > 0.005 && $seedRow && !empty($seedRow['reference_debit_id']),
  254.             'history' => array_reverse($history),
  255.         ];
  256.     }
  258.     #[Route(path: '/{id}/refund', name: 'admin_payments_refund', methods: ['POST'])]
  259.     public function refund(Payment $payment, Request $request, CommonServices $commonServices, ManagerRegistry $doctrine): JsonResponse
  260.     {
  261.         $gatewayConfig = $payment->getSite()?->getPaymentGatewayConfig();
  262.         $factoryName = $gatewayConfig?->getFactoryName();
  264.         if ('dimoco_pay' !== $factoryName) {
  265.             return $this->createErrorJsonResponse('Refunds are only available for Dimoco Pay payments.');
  266.         }
  268.         if ('completed' !== $payment->getPispStatus()) {
  269.             return $this->createErrorJsonResponse('Refunds are only available for completed payments.');
  270.         }
  272.         $payload = json_decode((string) $request->getContent(), true);
  273.         if (!is_array($payload)) {
  274.             $payload = [];
  275.         }
  277.         $amount = $payload['amount'] ?? null;
  278.         $reason = is_string($payload['reason'] ?? null) ? trim($payload['reason']) : '';
  280.         if (!is_numeric($amount) || (float) $amount <= 0) {
  281.             return $this->createErrorJsonResponse('Amount must be greater than 0.');
  282.         }
  284.         $amountInSubunits = (int) round(((float) $amount) * 100);
  286.         if ($amountInSubunits > $payment->getAmount()) {
  287.             return $this->createErrorJsonResponse('Amount cannot exceed the transaction amount.');
  288.         }
  290.         if ('' === $reason) {
  291.             return $this->createErrorJsonResponse('Please provide a reason for the refund.');
  292.         }
  294.         $paymentId = (string) $payment->getId();
  295.         $conn = $doctrine->getConnection();
  297.         $summary = $this->computeRefundSummary($payment, $conn);
  298.         $seedRow = $summary['seed_row'];
  300.         if (!$seedRow) {
  301.             return $this->createErrorJsonResponse('This payment cannot be refunded yet: no Dimoco session was recorded for it.');
  302.         }
  304.         if ($summary['in_progress']) {
  305.             return $this->createErrorJsonResponse('A refund is already in progress for this payment.');
  306.         }
  308.         $remaining = $summary['remaining_amount'];
  310.         if ($remaining <= 0) {
  311.             return $this->createErrorJsonResponse('This payment has already been fully refunded.');
  312.         }
  314.         if ((float) $amount > $remaining + 0.005) {
  315.             return $this->createErrorJsonResponse("Amount cannot exceed the remaining refundable amount ({$remaining}).");
  316.         }
  318.         if (empty($seedRow['reference_debit_id'])) {
  319.             return $this->createErrorJsonResponse('This payment cannot be refunded yet: the debit reference has not been received from Dimoco yet.');
  320.         }
  322.         $config = $gatewayConfig->getConfig();
  323.         $channelId = $config['client_id'] ?? null;
  324.         $xApiKey = $config['client_secret'] ?? null;
  325.         $sandbox = $config['sandbox'] ?? true;
  327.         if (!$channelId || !$xApiKey) {
  328.             return $this->createErrorJsonResponse('Missing Dimoco credentials in the gateway configuration.');
  329.         }
  331.         $refundRequestId = $conn->fetchOne(
  332.             'INSERT INTO refund_requests (payment_id, session_id, reference_debit_id, amount, reason, status, pisp_status)
  333.                 VALUES (:payment_id, :session_id, :reference_debit_id, :amount, :reason, :status, :pisp_status)
  334.                 RETURNING id',
  335.             [
  336.                 'payment_id' => $paymentId,
  337.                 'session_id' => $seedRow['session_id'],
  338.                 'reference_debit_id' => $seedRow['reference_debit_id'],
  339.                 'amount' => (string) $amount,
  340.                 'reason' => $reason,
  341.                 'status' => 'initiated',
  342.                 'pisp_status' => 'initiated',
  343.             ]
  344.         );
  346.         $refundPayload = [
  347.             'channel_id' => $channelId,
  348.             'reference_debit_id' => $seedRow['reference_debit_id'],
  349.             'amount' => $amountInSubunits,
  350.             'currency' => $payment->getCurrency(),
  351.             'url_callback' => $this->generateUrl(
  352.                 'dimoco_payment_webhook',
  353.                 ['id' => $paymentId],
  354.                 UrlGeneratorInterface::ABSOLUTE_URL
  355.             ),
  356.             'reason' => $reason,
  357.             'test_mode' => (bool) $sandbox,
  358.         ];
  360.         try {
  361.             $client = new Client(['timeout' => 30]);
  362.             $res = $client->post('https://api.upop.dinape.com/v1/refunds', [
  363.                 'headers' => [
  364.                     'Accept' => 'application/json',
  365.                     'Content-Type' => 'application/json',
  366.                     'X-Api-Key' => $xApiKey,
  367.                 ],
  368.                 'json' => $refundPayload,
  369.             ]);
  371.             $body = (string) $res->getBody();
  372.             $data = json_decode($body, true);
  373.             $refundSessionId = is_array($data) ? ($data['session_id'] ?? null) : null;
  375.             $conn->executeStatement(
  376.                 'UPDATE refund_requests SET refund_session_id = :refund_session_id, updated_at = CURRENT_TIMESTAMP WHERE id = :id',
  377.                 [
  378.                     'refund_session_id' => $refundSessionId,
  379.                     'id' => $refundRequestId,
  380.                 ]
  381.             );
  383.             $commonServices->savePaymentLogs($paymentId, Response::HTTP_OK, [
  384.                 'title' => 'Dimoco refund initiated',
  385.                 'details' => [
  386.                     'amount' => $amountInSubunits,
  387.                     'reason' => $reason,
  388.                     'response' => $data,
  389.                 ],
  390.             ]);
  392.             return new JsonResponse(['success' => true]);
  393.         } catch (ClientException|ServerException $e) {
  394.             $status = $e->getResponse()?->getStatusCode() ?? 502;
  395.             $errBody = $e->getResponse() ? (string) $e->getResponse()->getBody() : null;
  397.             $conn->executeStatement(
  398.                 'UPDATE refund_requests SET status = :status, pisp_status = :pisp_status, updated_at = CURRENT_TIMESTAMP WHERE id = :id',
  399.                 ['status' => 'failed', 'pisp_status' => 'failed', 'id' => $refundRequestId]
  400.             );
  402.             $commonServices->savePaymentLogs($paymentId, $status, [
  403.                 'title' => 'Dimoco refund API error',
  404.                 'details' => ['status' => $status, 'body' => $errBody],
  405.             ]);
  407.             return $this->createErrorJsonResponse('Dimoco refund failed: ' . ($errBody ?: $e->getMessage()));
  408.         } catch (GuzzleException $e) {
  409.             $conn->executeStatement(
  410.                 'UPDATE refund_requests SET status = :status, pisp_status = :pisp_status, updated_at = CURRENT_TIMESTAMP WHERE id = :id',
  411.                 ['status' => 'failed', 'pisp_status' => 'failed', 'id' => $refundRequestId]
  412.             );
  414.             $commonServices->savePaymentLogs($paymentId, 502, [
  415.                 'title' => 'Network error calling Dimoco refund API',
  416.                 'details' => ['error' => $e->getMessage()],
  417.             ]);
  419.             return $this->createErrorJsonResponse('Network error calling Dimoco.');
  420.         }
  421.     }
  423.     #[Route(path: '/export-all', name: 'admin_payments_export_all')]
  424.     public function exportAll(Request $request, ManagerRegistry $doctrine): StreamedResponse
  425.     {
  426.         $startYmd = $request->query->get('start');
  427.         $endYmd = $request->query->get('end');   // e.g. "2025-03-15"
  428.         $tzName = $request->query->get('tz') ?? \date_default_timezone_get() ?? 'UTC';
  430.         // --- Validate user tz (fallback to UTC) ---
  431.         try {
  432.             $userTz = new \DateTimeZone($tzName);
  433.         } catch (\Throwable) {
  434.             $tzName = 'UTC';
  435.             $userTz = new \DateTimeZone('UTC');
  436.         }
  438.         // --- Detect DB session timezone ---
  439.         $conn = $doctrine->getConnection();
  440.         $dbTzName = 'UTC';
  441.         try {
  442.             $platform = $conn->getDatabasePlatform()->getName();
  443.             if ($platform === 'mysql') {
  444.                 $sessionTz = $conn->fetchOne('SELECT @@time_zone');
  445.                 if ($sessionTz === 'SYSTEM') {
  446.                     $systemTz = $conn->fetchOne('SELECT @@system_time_zone');
  447.                     $dbTzName = $systemTz ?: 'UTC';
  448.                 } else {
  449.                     $dbTzName = $sessionTz ?: 'UTC';
  450.                 }
  451.             } elseif ($platform === 'postgresql') {
  452.                 $dbTzName = $conn->fetchOne('SHOW TIME ZONE') ?: 'UTC';
  453.             }
  454.         } catch (\Throwable) {
  455.             // keep default UTC
  456.         }
  457.         try {
  458.             $dbTz = new \DateTimeZone($dbTzName);
  459.         } catch (\Throwable) {
  460.             $dbTzName = 'UTC';
  461.             $dbTz = new \DateTimeZone('UTC');
  462.         }
  464.         $repo = $doctrine->getRepository(Payment::class);
  465.         $qb = $repo->createQueryBuilder('p');
  467.         // join user_payment_info
  468.         $qb->leftJoin('p.userPaymentInfo', 'upi')
  469.             ->addSelect('upi');
  471.         // --- Apply timezone-aware date filter if provided ---
  472.         if ($startYmd && $endYmd) {
  473.             $startLocal = \DateTimeImmutable::createFromFormat('Y-m-d H:i:s', trim($startYmd) . ' 00:00:00', $userTz);
  474.             $endLocal = \DateTimeImmutable::createFromFormat('Y-m-d H:i:s', trim($endYmd) . ' 23:59:59', $userTz);
  476.             if (!$startLocal || !$endLocal) {
  477.                 throw new \RuntimeException('Invalid start/end date.');
  478.             }
  480.             $startDb = $startLocal->setTimezone($dbTz);
  481.             $endDb = $endLocal->setTimezone($dbTz);
  483.             $qb->andWhere('p.createdAt BETWEEN :start AND :end')
  484.                 ->setParameter('start', $startDb, 'datetime_immutable')
  485.                 ->setParameter('end', $endDb, 'datetime_immutable');
  486.         }
  488.         $qb->orderBy('p.createdAt', 'DESC');
  490.         $payments = $qb->getQuery()->getResult();
  492.         // --- Stream CSV; render "Created At" in the USER'S timezone ---
  493.         $response = new StreamedResponse(function () use ($payments, $userTz) {
  494.             $handle = fopen('php://output', 'w+');
  496.             // Header
  497.             fputcsv($handle, ['ID', 'External ID', 'Site', 'Payment Provider', 'IP Address', 'Name', 'PISP Status', 'Bank Status', 'Amount', 'Currency', 'Created At']);
  499.             // Rows
  500.             /** @var \App\Domain\Payment\Model\Payment $payment */
  501.             foreach ($payments as $payment) {
  502.                 $createdAt = $payment->getCreatedAt();
  503.                 $createdAtStr = $createdAt
  504.                     ? (new \DateTimeImmutable('@' . $createdAt->getTimestamp()))
  505.                         ->setTimezone($userTz)
  506.                         ->format('Y-m-d H:i:s')
  507.                     : '';
  509.                 //ADDING BELOW CODE, BECAUSE PAYMENT PROVIDER, PISP STATUS AND BANK STATUS ARE NOT SET IN FOR OLD PAYMENT ENTITY
  510.                 $paymentProvider = '';
  511.                 try {
  512.                     $tmp = $payment->getSite()?->getPaymentGatewayConfig()?->getFactoryName();
  513.                     if (is_string($tmp) && $tmp !== '') {
  514.                         $paymentProvider = $tmp;
  515.                     }
  516.                 } catch (\Throwable $e) {
  517.                     // ignore errors for old data
  518.                 }
  520.                 $pispStatus = '';
  521.                 try {
  522.                     $tmp = $payment->getPispStatus();
  523.                     if (is_string($tmp) && $tmp !== '') {
  524.                         $pispStatus = $tmp;
  525.                     }
  526.                 } catch (\Throwable $e) {
  527.                 }
  529.                 $bankStatus = '';
  530.                 try {
  531.                     $tmp = $payment->getBankStatus();
  532.                     if (is_string($tmp) && $tmp !== '') {
  533.                         $bankStatus = $tmp;
  534.                     }
  535.                 } catch (\Throwable $e) {
  536.                 }
  538.                 $upi = $payment->getUserPaymentInfo();
  539.                 $ip = $upi ? $upi->getIpAddress() : null;
  540.                 $name = $upi ? $upi->getName() : null;
  542.                 fputcsv($handle, [
  543.                     $payment->getId(),
  544.                     $payment->getExternalId(),
  545.                     $payment->getSite()?->getName(),
  546.                     // $payment->getStatus()?->getValue(),
  547.                     $paymentProvider,
  548.                     $ip,
  549.                     $name,
  550.                     $pispStatus,
  551.                     $bankStatus,
  552.                     $payment->getAmount() / 100,
  553.                     $payment->getCurrency(),
  554.                     $createdAtStr,
  555.                 ]);
  556.             }
  558.             fclose($handle);
  559.         });
  561.         $filename = 'payments_' . date('Ymd_His') . '.csv';
  562.         $response->headers->set('Content-Type', 'text/csv');
  563.         $response->headers->set('Content-Disposition', 'attachment; filename="' . $filename . '"');
  565.         return $response;
  566.     }
  568.     #[Route(path: '/payment-logs', name: 'admin_payment_logs')]
  569.     public function paymentLogs(Request $request, ManagerRegistry $doctrine): StreamedResponse
  570.     {
  571.         $paymentId = $request->query->get('payment_id');
  572.         if (!$paymentId) {
  573.             throw new \InvalidArgumentException("payment_id is required");
  574.         }
  576.         $conn = $doctrine->getConnection();
  578.         $query = <<<SQL
  579.         SELECT id, payment_id, status_code, timestamp, logs, created_at, updated_at
  580.         FROM payment_logs
  581.         WHERE payment_id = :paymentId
  582.         ORDER BY timestamp DESC, id DESC
  583.     SQL;
  585.         $stmt = $conn->prepare($query);
  586.         $result = $stmt->executeQuery(['paymentId' => $paymentId]);
  587.         $rows = $result->fetchAllAssociative();
  589.         // Helper to decode possibly-double-encoded JSON into an array.
  590.         $decodeMaybe = static function ($value, int $maxPasses = 3): array {
  591.             if (is_array($value)) {
  592.                 return $value;
  593.             }
  594.             if (!is_string($value) || $value === '') {
  595.                 return [];
  596.             }
  598.             $s = $value;
  600.             for ($i = 0; $i < $maxPasses; $i++) {
  601.                 $decoded = json_decode($s, true);
  602.                 if (json_last_error() === JSON_ERROR_NONE) {
  603.                     if (is_array($decoded)) {
  604.                         return $decoded;               // got the object/array
  605.                     }
  606.                     if (is_string($decoded)) {
  607.                         $s = $decoded;                 // it was a JSON string containing JSON — try again
  608.                         continue;
  609.                     }
  610.                     // scalar/null → fall through to cleanup
  611.                 }
  613.                 // Cleanup pass: trim, strip wrapping quotes, unescape backslashes
  614.                 $s = trim($s);
  615.                 $len = strlen($s);
  616.                 if ($len >= 2) {
  617.                     $first = $s[0];
  618.                     $last = $s[$len - 1];
  619.                     if (($first === '"' && $last === '"') || ($first === "'" && $last === "'")) {
  620.                         $s = substr($s, 1, -1);
  621.                     }
  622.                 }
  623.                 $s = stripslashes($s);
  624.             }
  626.             return [];
  627.         };
  629.         $responseData = [];
  630.         foreach ($rows as $log) {
  631.             $logsArray = $decodeMaybe($log['logs'] ?? '');
  633.             // Normalize details: if it's a JSON string, decode it once.
  634.             $details = $logsArray['details'] ?? '';
  635.             if (is_string($details) && $details !== '') {
  636.                 $maybe = json_decode($details, true);
  637.                 if (json_last_error() === JSON_ERROR_NONE && is_array($maybe)) {
  638.                     $details = $maybe;
  639.                 }
  640.             }
  642.             $responseData[] = [
  643.                 'title' => $logsArray['title'] ?? '',
  644.                 'details' => $details,
  645.                 'timestamp' => $log['timestamp'],
  646.                 'status_code' => $log['status_code'],
  647.             ];
  648.         }
  650.         return new StreamedResponse(function () use ($responseData) {
  651.             echo json_encode($responseData, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
  652.         }, 200, [
  653.             'Content-Type' => 'application/json',
  654.         ]);
  655.     }
  656. }