src/Aviatur/GeneralBundle/Services/AviaturWebService.php line 141

Open in your IDE?
  1. <?php
  3. namespace Aviatur\GeneralBundle\Services;
  5. /*
  6.  * To change this template, choose Tools | Templates
  7.  * and open the template in the editor.
  8.  */
  10. use Aviatur\GeneralBundle\Entity\ProviderResponse;
  11. use Aviatur\GeneralBundle\Services\Exception\WebServiceException;
  12. use Doctrine\Bundle\DoctrineBundle\Registry;
  13. use Symfony\Component\HttpFoundation\RequestStack;
  14. use Symfony\Component\HttpFoundation\Session\SessionInterface;
  15. use Symfony\Component\Stopwatch\Stopwatch;
  17. /**
  18.  * Description of AviaturWebService.
  19.  *
  20.  * @author andres.ramirez
  21.  */
  22. class AviaturWebService
  23. {
  24.     // Timeouts y configuraciones de performance
  25.     private const CURL_TIMEOUT = 120;
  26.     private const CURL_CONNECT_TIMEOUT = 60;
  27.     private const CURL_TIMEOUT_MPB = 60;
  28.     private const CURL_CONNECT_TIMEOUT_MPB = 10;
  29.     private const SESSION_EXPIRATION_TIME = 7200;
  30.     private const SESSION_VALIDATION_THRESHOLD = 900;
  32.     // Mensajes de error estandarizados
  33.     private const ERROR_CURL = 'cURL Error: %s';
  34.     private const ERROR_HTTP = 'HTTP Error: %d';
  35.     private const ERROR_EMPTY_RESPONSE = 'Respuesta vacia del servicio';
  36.     private const ERROR_XML_PARSE = 'Error: Failed to parse XML response.';
  37.     private const ERROR_SOAP_FAULT = 'Error en la respuesta del servicio: %s';
  38.     private const ERROR_NO_AVAILABILITY = 'No existe disponibilidad para esta solicitud, por favor intenta con diferentes fechas o destinos.(66002 )';
  40.     private $url;
  41.     private $urlMpa;
  42.     private $serviceNameMpa;
  43.     private $invoker;
  44.     private $requestId;
  45.     private $requestType;
  46.     private $projectDir;
  47.     private $loginKey;
  48.     private \Symfony\Component\HttpFoundation\Session\SessionInterface $session;
  49.     private \Symfony\Component\HttpFoundation\RequestStack $requestStack;
  50.     private \Doctrine\Bundle\DoctrineBundle\Registry $doctrine;
  51.     private \Aviatur\GeneralBundle\Services\AviaturLogSave $aviaturLogSave;
  52.     private \Aviatur\GeneralBundle\Services\ExceptionLog $aviaturRegisterException;
  53.     private $transactionIdSessionName;
  54.     private $stopwatch;
  56.     // URLs específicas para servicios MPB
  57.     private $urlLoginMpb;
  58.     private $urlAirMpb;
  59.     private $urlHotelMpb;
  60.     private $urlCarMpb;
  61.     private $urlTicketMpb;
  62.     private $urlCruiseMpb;
  63.     private $urlEmission;
  64.     private $urlPackageMpt;
  65.     private $urlInsuranceMpb;
  66.     private $urlBusMpb;
  67.     private $urlTrainMpb;
  68.     private $urlExperience;
  70.     // Cache para métodos disponibles por servicio
  71.     private array $availableMethodsByService = [];
  73.     /**
  74.      * Establece la URL del bus.
  75.      *
  76.      * @param string $url
  77.      * @return void
  78.      */
  79.     public function setUrl(string $url): void
  80.     {
  81.         $this->url = $url;
  82.     }
  84.     /**
  85.      * Establece la URL del MPA.
  86.      *
  87.      * @param string $urlMpa
  88.      * @return void
  89.      */
  90.     public function setUrlMpa(string $urlMpa): void
  91.     {
  92.         $this->urlMpa = $urlMpa;
  93.     }
  95.     /**
  96.      * Establece el tipo de consulta si es MPA o BUS.
  97.      *
  98.      * @param string $requestType
  99.      * @return void
  100.      */
  101.     public function setRequestType(string $requestType): void
  102.     {
  103.         $this->requestType = $requestType;
  104.     }
  106.     /**
  107.      * Obtiene el valor del requestType para consultar en clases que van a extender.
  108.      *
  109.      * @return string|null
  110.      */
  111.     public function getRequestType(): ?string
  112.     {
  113.         return $this->requestType;
  114.     }
  116.     /**
  117.      * @param $projectDir
  118.      * @param $invoker
  119.      * @param SessionInterface $session
  120.      * @param RequestStack $requestStack
  121.      * @param Registry $doctrine
  122.      * @param AviaturLogSave $aviaturLogSave
  123.      * @param ExceptionLog $aviaturRegisterException
  124.      * @param Stopwatch $stopwatch
  125.      * @param $transactionIdSessionName
  126.      */
  127.     public function __construct(RequestStack $requestStack, SessionInterface $session, Registry $doctrine, AviaturLogSave $aviaturLogSave, ExceptionLog $aviaturRegisterException, Stopwatch $stopwatch, $projectDir, $invoker, $transactionIdSessionName)
  128.     {
  129.         $this->projectDir = $projectDir;
  130.         $this->session = $session;
  131.         $this->requestStack = $requestStack;
  132.         $this->doctrine = $doctrine;
  133.         $this->aviaturLogSave = $aviaturLogSave;
  134.         $this->aviaturRegisterException = $aviaturRegisterException;
  135.         $this->transactionIdSessionName = $transactionIdSessionName;
  136.         $this->stopwatch = $stopwatch;
  138.         $request = $this->requestStack->getCurrentRequest();
  139.         if (null !== $request) {
  140.             $domain = $request->getHost();
  141.             $parametersJson = $this->session->get($domain . '[parameters]', '');
  142.             $parameters = json_decode($parametersJson);
  144.             if (!empty($parameters)) {
  145.                 $this->url = $parameters->aviatur_service_web_url;
  146.                 $this->urlMpa = $parameters->aviatur_service_web_url_mpa;
  147.                 $this->urlLoginMpb = $parameters->aviatur_service_web_url_login_mpb;
  148.                 $this->urlAirMpb = $parameters->aviatur_service_web_url_air_mpb;
  149.                 $this->urlHotelMpb = $parameters->aviatur_service_web_url_hotel_mpb;
  150.                 $this->urlCarMpb = $parameters->aviatur_service_web_url_car_mpb;
  151.                 $this->urlTicketMpb = $parameters->aviatur_service_web_url_ticket_mpb;
  152.                 $this->urlCruiseMpb = $parameters->aviatur_service_web_url_cruise_mpb;
  153.                 $this->urlEmission = $parameters->aviatur_service_web_url_emission;
  154.                 $this->invoker = $invoker;
  155.                 $this->requestId = $parameters->aviatur_service_web_request_id;
  156.                 $this->requestType = $parameters->aviatur_service_web_request_type;
  157.                 $this->serviceNameMpa = $parameters->aviatur_service_web_mpa_method;
  158.                 $this->urlPackageMpt = $parameters->aviatur_service_web_mpb_mpt;
  159.                 $this->urlInsuranceMpb = $parameters->aviatur_service_web_url_insurance_mpb;
  160.                 $this->urlBusMpb = $parameters->aviatur_service_web_url_bus_mpb;
  161.                 $this->urlTrainMpb = $parameters->aviatur_service_web_url_train_mpb;
  162.                 $this->urlExperience = $parameters->aviatur_service_web_mpb_experience;
  163.             }
  164.         }
  166.         $this->loginKey = base64_decode('Tj6qJt6p2QYECN4Z+4iqQMbLFuz8u5ff');
  167.     }
  169.     /**
  170.      * @param string $xml
  171.      *
  172.      * @return string
  173.      *
  174.      * @throws FatalErrorException
  175.      */
  176.     public function callWebService($service, $provider, $xmlRequest)
  177.     {
  178.         $xmlResponseObject = $this->callServiceBus($this->projectDir, $service, $provider, $xmlRequest);
  180.         return $xmlResponseObject;
  181.     }
  183.     /**
  184.      * Realiza la consulta en los servicios de amadeus usando un entrypoint diferente dependiendo de la configuracion.
  185.      *
  186.      * @param string $service
  187.      * @param string $method
  188.      * @param string $provider
  189.      * @param string $xmlRequest
  190.      * @param array $variable
  191.      * @param bool $login
  192.      * @param string|null $transactionId
  193.      * @param bool $isTicket
  194.      *
  195.      * @return \SimpleXMLElement|array
  196.      */
  197.     public function callWebServiceAmadeus($service, $method, $provider, $xmlRequest, array $variable, $login = false, $transactionId = null, $isTicket = true)
  198.     {
  199.         $this->stopwatch->start('Set request options');
  201.         // Inicializar cache de métodos disponibles si no existe
  202.         if (empty($this->availableMethodsByService)) {
  203.             $this->initializeAvailableMethods();
  204.         }
  206.         // Determinar si el método requiere MPA en lugar de MPB
  207.         if ($this->requestType === 'MPB' && !$this->isMethodAvailableForMpb($method)) {
  208.             $this->requestType = 'MPA';
  209.         }
  210.         $this->stopwatch->stop('Set request options');
  212.         $this->stopwatch->start('Checks for transaction');
  213.         $transactionId = $this->resolveTransactionId($service, $provider, $variable, $login, $transactionId);
  214.         if (isset($transactionId['error'])) {
  215.             return $transactionId;
  216.         }
  218.         $validationResult = $this->validateTransactionExpiration($transactionId);
  219.         if ($validationResult !== null) {
  220.             return $validationResult;
  221.         }
  222.         $this->stopwatch->stop('Checks for transaction');
  224.         $this->stopwatch->start('Defines request method and calls');
  225.         $xmlResponseObject = $this->executeServiceCall($service, $provider, $method, $xmlRequest, $variable, $transactionId, $isTicket);
  226.         $this->stopwatch->stop('Defines request method and calls');
  228.         return $xmlResponseObject;
  229.     }
  231.     /**
  232.      * Realiza la consulta en en servicio para mirar si el usuario existe en la base de Aviatur.
  233.      *
  234.      * @param string $service
  235.      * @param string $provider
  236.      * @param string $xmlRequest
  237.      *
  238.      * @return \simplexml_object
  239.      */
  240.     public function busWebServiceAmadeus($service, $provider, $xmlRequest)
  241.     {
  242.         $xmlResponseObject = $this->callServiceBusUser($service, $provider, $xmlRequest);
  244.         return $xmlResponseObject;
  245.     }
  247.     /**
  248.      * Consulta el bus enviando los xml mediante curl.
  249.      *
  250.      * @param $projectDir
  251.      * @param string $service
  252.      * @param string $provider
  253.      * @param xml    $xmlRequest
  254.      *
  255.      * @return \simplexml_object
  256.      *
  257.      * @throws WebServiceException
  258.      */
  259.     private function callServiceBus($projectDir, $service, $provider, $xmlRequest)
  260.     {
  261.         $xmlResponseObject = null;
  262.         try {
  263.             if (null != $service) {
  264.                 $path = $projectDir . '/app/xmlService/aviaturRequest.xml';
  265.                 //Valores a remplazar
  266.                 $arrayIndex = [
  267.                     '{xmlBody}',
  268.                     '{service}',
  269.                     '{invoker}',
  270.                     '{provider}',
  271.                     '{requestId}',
  272.                 ];
  273.                 //Nuevos valores
  274.                 $arrayValues = [
  275.                     $xmlRequest,
  276.                     $service,
  277.                     $this->invoker,
  278.                     $provider,
  279.                     $this->requestId,
  280.                 ];
  281.                 //obtengo el xml base
  282.                 $xmlBase = simplexml_load_file((string) $path)->asXML();
  283.                 $xmlBase = str_replace($arrayIndex, $arrayValues, $xmlBase);
  284.                 $xmlBase = str_replace('<?xml version="1.0"?>', '', $xmlBase);
  285.                 $xmlBase = trim($xmlBase);
  286.             } else {
  287.                 $xmlBase = $xmlRequest;
  288.                 $service = 'DIRECT';
  289.             }
  290.             $client = new \SoapClient(null, [
  291.                 'location' => $this->url,
  292.                 'uri' => $this->url,
  293.                 'trace' => 1,
  294.             ]);
  295.             $this->aviaturLogSave->logSave($xmlBase, $service, 'RQ');
  296.             $response = $client->__doRequest($xmlBase, $this->url, $this->serviceNameMpa, 1);
  297.             $this->aviaturLogSave->logSave($response, $service, 'RS');
  299.             $response = str_replace('<?xml version="1.0"?>', '', $response);
  300.             $xmlResponseObject = \simplexml_load_string($response, \SimpleXMLElement::class, 0, 'NS1', true);
  301.             if (isset($xmlResponseObject->Body->mbus->response->fault)) {
  302.                 $this->aviaturRegisterException->log(
  303.                     $xmlBase,
  304.                     $response
  305.                 );
  307.                 return ['error' => 'Error en la respuesta del servicio: ' . (string) $xmlResponseObject->Body->mbus->response->fault->faultDescription];
  308.             }
  309.             if (false === strpos($response, '<body>')) {
  310.                 $this->aviaturRegisterException->log(
  311.                     $xmlBase,
  312.                     $response
  313.                 );
  315.                 return ['error' => 'Respuesta vacia del servicio'];
  316.             }
  317.             //Si no existe error Extraigo el body de la respuesta
  318.             $firstPartBody = explode('<body>', $response);
  319.             $secondPartBody = explode('</body>', $firstPartBody[1]);
  320.             $xmlResponseObject = str_replace('mpa:', '', utf8_encode($secondPartBody[0]));
  321.             $xmlResponseObject = \simplexml_load_string($xmlResponseObject, \SimpleXMLElement::class, LIBXML_NOCDATA);
  322.         } catch (\SoapFault $e) {
  323.             $this->aviaturRegisterException->log(
  324.                 'SoapFault Exception',
  325.                 json_encode($e)
  326.             );
  327.             throw new WebServiceException('No se pudo realizar la consulta en el servidor. ' . $this->url, '', 100);
  328.         }
  330.         return $xmlResponseObject;
  331.     }
  333.     /**
  334.      * A template for the SOAP request envelope. Stored as a constant to avoid file reads.
  335.      */
  336.     private const SOAP_TEMPLATE = <<<XML
  337. <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:ns="http://www.aviatur.com/soa/formato/mbus/request/version/1.0">
  338.     <soapenv:Header/>
  339.     <soapenv:Body>
  340.         <ns:mbus>
  341.             <ns:request>
  342.                 <ns:header>
  343.                     <ns:service>{service}</ns:service>
  344.                     <ns:invoker>{invoker}</ns:invoker>
  345.                     <ns:provider>{provider}</ns:provider>
  346.                     <ns:requestId>{requestId}</ns:requestId>
  347.                 </ns:header>
  348.                 <ns:body>{xmlBody}</ns:body>
  349.             </ns:request>
  350.         </ns:mbus>
  351.     </soapenv:Body>
  352. </soapenv:Envelope>
  353. XML;
  355.     /**
  356.      * Inicializa el cache de métodos disponibles por servicio.
  357.      * Optimización: se ejecuta una sola vez y se mantiene en memoria.
  358.      */
  359.     private function initializeAvailableMethods(): void
  360.     {
  361.         $this->availableMethodsByService = [
  362.             'air' => ['AirOverride', 'AirLowFareSearch', 'AirDetail', 'AirAvail', 'AirCommandExecute', 'AirAddDataPassenger', 'AirBook', 'AirCancel'],
  363.             'car' => ['VehOverride', 'VehAvailRate', 'VehDetail', 'VehRes'],
  364.             'hotel' => ['HotelAvail', 'HotelRoomList', 'HotelDetail', 'HotelRes'],
  365.             'ticket' => ['SvcDetail'],
  366.             'package' => ['PkgAvail', 'PkgDetail', 'PkgFares', 'PkgOptions', 'PkgPromo'],
  367.             'cruise' => ['CruiseAvail', 'CruiseDetail', 'CruiseCabin', 'CruiseReserve'],
  368.             'insurance' => ['InsuranceQuote', 'InsuranceBook'],
  369.             'bus' => ['BusAvail', 'BusDetail', 'BusBook'],
  370.             'train' => ['TrainAvail', 'TrainDetail', 'TrainBook'],
  371.             'experience' => ['SvcAvail', 'SvcDetail', 'SvcAvailComb', 'SvcFares', 'SvcAvailPOS', 'SvcAvailPROMO', 'SvcQuotas'],
  372.         ];
  373.     }
  375.     /**
  376.      * Verifica si un método está disponible para MPB.
  377.      */
  378.     private function isMethodAvailableForMpb(string $method): bool
  379.     {
  380.         foreach ($this->availableMethodsByService as $methods) {
  381.             if (in_array($method, $methods, true)) {
  382.                 return true;
  383.             }
  384.         }
  385.         return false;
  386.     }
  388.     /**
  389.      * Resuelve el transaction ID, ya sea obteniendo uno nuevo o usando el existente.
  390.      *
  391.      * @return string|array Transaction ID o array con error
  392.      */
  393.     private function resolveTransactionId(string $service, string $provider, array $variable, bool $login, ?string $transactionId)
  394.     {
  395.         if ($transactionId !== null) {
  396.             return $transactionId;
  397.         }
  399.         if ($login || !$this->session->has($this->transactionIdSessionName)) {
  400.             $transactionId = $this->loginService($service, $provider, $variable['ProviderId']);
  401.             if (isset($transactionId['error'])) {
  402.                 return $transactionId;
  403.             }
  404.             $this->session->set($this->transactionIdSessionName, (string) $transactionId);
  405.             return $transactionId;
  406.         }
  408.         return $this->session->get($this->transactionIdSessionName);
  409.     }
  411.     /**
  412.      * Valida que el transaction ID no haya expirado.
  413.      *
  414.      * @return array|null Array con error si expiró, null si es válido
  415.      */
  416.     private function validateTransactionExpiration(string $transactionId): ?array
  417.     {
  418.         try {
  419.             $tokenParts = explode('.', $this->encodeJWT('', $this->loginKey));
  420.             $fullToken = $tokenParts[0] . '.' . $transactionId;
  421.             $infoToken = $this->decodeJWT($fullToken, $this->loginKey, ['HS256']);
  423.             $timeValidation = explode('_', $infoToken->e);
  424.             $expirationTime = (int) $timeValidation[0];
  425.             $currentTime = time();
  427.             if ($expirationTime <= ($currentTime - self::SESSION_VALIDATION_THRESHOLD)) {
  428.                 return ['error' => 'La sesión ha expirado por favor vuelve a realizar tu consulta. (66002 ) '];
  429.             }
  430.         } catch (\Exception $e) {
  431.             return ['error' => 'Error validando la sesión. Por favor intenta nuevamente.'];
  432.         }
  434.         return null;
  435.     }
  437.     /**
  438.      * Ejecuta la llamada al servicio según el tipo de request configurado.
  439.      *
  440.      * @return \SimpleXMLElement|array
  441.      */
  442.     private function executeServiceCall(string $service, string $provider, string $method, string $xmlRequest, array $variable, string $transactionId, bool $isTicket)
  443.     {
  444.         switch ($this->requestType) {
  445.             case 'BUS':
  446.                 $this->stopwatch->start('Calls using BUS');
  447.                 $xmlRequest = $this->getXmlBusHeader($xmlRequest, $method, $transactionId, $variable);
  448.                 $result = $this->callServiceBusUser($service, $provider, $xmlRequest, $transactionId);
  449.                 $this->stopwatch->stop('Calls using BUS');
  450.                 return $result;
  452.             case 'MPA':
  453.                 $this->stopwatch->start('Calls using MPA');
  454.                 $xmlRequest = $this->getXmlMpxHeader($xmlRequest, $method, $transactionId, $variable);
  455.                 $result = $this->callServiceMpa($this->projectDir, $method, $xmlRequest, $transactionId);
  456.                 $this->stopwatch->stop('Calls using MPA');
  457.                 return $result;
  459.             case 'MPB':
  460.                 $this->stopwatch->start('Calls using MPB');
  461.                 $xmlRequest = $this->getXmlMpxHeader($xmlRequest, $method, $transactionId, $variable);
  462.                 $result = $this->routeMpbRequest($method, $xmlRequest, $transactionId, $isTicket);
  463.                 $this->stopwatch->stop('Calls using MPB');
  464.                 return $result;
  466.             default:
  467.                 return ['error' => 'Tipo de request no válido: ' . $this->requestType];
  468.         }
  469.     }
  471.     /**
  472.      * Enruta la petición MPB al servicio correspondiente según el método.
  473.      *
  474.      * @return \SimpleXMLElement|array
  475.      */
  476.     private function routeMpbRequest(string $method, string $xmlRequest, string $transactionId, bool $isTicket)
  477.     {
  478.         $serviceMap = [
  479.             'air' => $this->urlAirMpb ?? null,
  480.             'car' => $this->urlCarMpb ?? null,
  481.             'hotel' => $this->urlHotelMpb ?? null,
  482.             'ticket' => $isTicket ? ($this->urlTicketMpb ?? null) : null,
  483.             'package' => $this->urlPackageMpt ?? null,
  484.             'cruise' => $this->urlCruiseMpb ?? null,
  485.             'insurance' => $this->urlInsuranceMpb ?? null,
  486.             'bus' => $this->urlBusMpb ?? null,
  487.             'train' => $this->urlTrainMpb ?? null,
  488.             'experience' => $this->urlExperience ?? null,
  489.         ];
  491.         foreach ($serviceMap as $serviceType => $url) {
  492.             if ($url && in_array($method, $this->availableMethodsByService[$serviceType], true)) {
  493.                 return $this->callServiceMpb($method, $xmlRequest, $url, $transactionId);
  494.             }
  495.         }
  497.         // Fallback a MPA si no se encuentra el servicio
  498.         return $this->callServiceMpa($this->projectDir, $method, $xmlRequest, $transactionId);
  499.     }
  501.     /**
  502.      * Performs a direct SOAP query to the MPB service.
  503.      *
  504.      * @param string $service
  505.      * @param string $provider
  506.      * @param string $xmlRequest
  507.      * @param string|null $transactionId
  508.      *
  509.      * @return \SimpleXMLElement|array Returns a SimpleXMLElement on success or an array with an 'error' key on failure.
  510.      */
  511.     private function callServiceBusUser($service, $provider, $xmlRequest, $transactionId = null)
  512.     {
  513.         try {
  514.             // Section 1: Build the request XML in memory
  515.             if (null !== $service) {
  516.                 $placeholders = [
  517.                     '{service}',
  518.                     '{invoker}',
  519.                     '{provider}',
  520.                     '{requestId}',
  521.                     '{xmlBody}',
  522.                 ];
  523.                 $values = [
  524.                     $service,
  525.                     $this->invoker,
  526.                     $provider,
  527.                     $this->requestId,
  528.                     $xmlRequest,
  529.                 ];
  530.                 $xmlBase = str_replace($placeholders, $values, self::SOAP_TEMPLATE);
  531.             } else {
  532.                 $xmlBase = $xmlRequest;
  533.                 $service = 'DIRECT';
  534.             }
  536.             // Section 2: Execute the cURL request
  537.             $headers = [
  538.                 'Content-Type: text/xml; charset=utf-8',
  539.                 'SOAPAction: "' . $this->serviceNameMpa . '"'
  540.             ];
  541.             $options = [
  542.                 CURLOPT_URL            => $this->url,
  543.                 CURLOPT_RETURNTRANSFER => true,
  544.                 CURLOPT_POST           => true,
  545.                 CURLOPT_HTTPHEADER     => $headers,
  546.                 CURLOPT_POSTFIELDS     => $xmlBase,
  547.                 CURLOPT_TIMEOUT        => self::CURL_TIMEOUT,
  548.                 CURLOPT_CONNECTTIMEOUT => self::CURL_CONNECT_TIMEOUT,
  549.                 CURLOPT_SSL_VERIFYHOST => false, // SECURITY RISK: Use 2 in production
  550.                 CURLOPT_SSL_VERIFYPEER => false, // SECURITY RISK: Use true in production
  551.             ];
  553.             $ch = curl_init();
  554.             curl_setopt_array($ch, $options);
  556.             $this->aviaturLogSave->logSave($xmlBase, $service, 'RQ', $transactionId);
  557.             $responseBody = curl_exec($ch);
  559.             // Section 3: Handle transport-level errors
  560.             $curlError = curl_error($ch);
  561.             $httpCode = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
  562.             curl_close($ch);
  564.             $this->aviaturLogSave->logSave($responseBody ?: $curlError, $service, 'RS', $transactionId);
  566.             if ($curlError) {
  567.                 return ['error' => sprintf(self::ERROR_CURL, $curlError)];
  568.             }
  569.             if ($httpCode >= 400) {
  570.                 return ['error' => sprintf(self::ERROR_HTTP, $httpCode)];
  571.             }
  572.             if (empty($responseBody)) {
  573.                 return ['error' => self::ERROR_EMPTY_RESPONSE];
  574.             }
  576.             // Section 4: Safely parse the XML response
  577.             $previousLibxmlState = libxml_use_internal_errors(true);
  578.             $responseXml = simplexml_load_string($responseBody);
  580.             if ($responseXml === false) {
  581.                 libxml_use_internal_errors($previousLibxmlState);
  582.                 $this->aviaturRegisterException->log($xmlBase, $responseBody);
  583.                 return ['error' => self::ERROR_XML_PARSE];
  584.             }
  586.             $responseXml->registerXPathNamespace('soap', 'http://schemas.xmlsoap.org/soap/envelope/');
  588.             // Check for a SOAP Fault error
  589.             $fault = $responseXml->xpath('//soap:Body/soap:Fault');
  590.             if (!empty($fault)) {
  591.                 libxml_use_internal_errors($previousLibxmlState);
  592.                 $faultDescription = (string) ($fault[0]->faultstring ?? 'Unknown SOAP fault');
  593.                 $this->aviaturRegisterException->log($xmlBase, $responseBody);
  594.                 return ['error' => sprintf(self::ERROR_SOAP_FAULT, $faultDescription)];
  595.             }
  597.             // Extract the main content from inside the <body> tag
  598.             $bodyContent = $responseXml->xpath('//soap:Body/*[1]');
  599.             if (empty($bodyContent)) {
  600.                 libxml_use_internal_errors($previousLibxmlState);
  601.                 return ['error' => 'Respuesta vacia del servicio (cuerpo SOAP vacío).'];
  602.             }
  604.             // Usar regex en lugar de explode para mejor performance
  605.             $bodyXml = $bodyContent[0]->asXML();
  606.             if (preg_match('/<body>(.*?)<\/body>/s', $bodyXml, $matches)) {
  607.                 $innerContent = $matches[1];
  608.             } else {
  609.                 libxml_use_internal_errors($previousLibxmlState);
  610.                 return ['error' => 'No se pudo extraer el contenido del body.'];
  611.             }
  613.             $xmlResponseObject = str_replace('mpa:', '', utf8_encode($innerContent));
  614.             if ($service === 'DIRECT') {
  615.                 $xmlResponseObject = '<ROW>' . $xmlResponseObject . '</ROW>';
  616.             }
  618.             $xmlResponseObject = simplexml_load_string(trim($xmlResponseObject), 'SimpleXMLElement', LIBXML_NOCDATA);
  619.             libxml_use_internal_errors($previousLibxmlState);
  621.             if ($xmlResponseObject === false) {
  622.                 $this->aviaturRegisterException->log($xmlBase, $responseBody);
  623.                 return ['error' => 'Error al parsear el contenido del body.'];
  624.             }
  626.             // Validar resultados del proveedor
  627.             if (isset($xmlResponseObject->ProviderResults)) {
  628.                 $validResponse = false;
  629.                 foreach ($xmlResponseObject->ProviderResults->ProviderResult as $providerResult) {
  630.                     if (isset($providerResult['Code']) && (string) $providerResult['Code'] === '0') {
  631.                         $validResponse = true;
  632.                         break;
  633.                     }
  634.                 }
  635.                 if (!$validResponse) {
  636.                     $message = (string) ($xmlResponseObject->ProviderResults->ProviderResult[0]['Message'] ?? 'Provider returned an unspecified error.');
  637.                     $this->aviaturRegisterException->log($xmlBase, $responseBody);
  638.                     return ['error' => $message];
  639.                 }
  640.             }
  642.         } catch (\Exception $e) {
  643.             $this->aviaturRegisterException->log($xmlRequest, json_encode($e->getMessage()));
  644.             return ['error' => 'No se pudo realizar la consulta en el servidor: ' . $e->getMessage()];
  645.         }
  647.         return $xmlResponseObject;
  648.     }
  650.     /**
  651.      * Realiza la consulta directamente en el servicio del mpa.
  652.      *
  653.      * @param string $xmlRequest
  654.      *
  655.      * @return \simplexml_object
  656.      *
  657.      * @throws WebServiceException
  658.      */
  659.     private function callServiceMpa($projectDir, $method, $xmlRequest, $transactionId = null)
  660.     {
  661.         $xmlResponseObject = null;
  662.         try {
  663.             $client = new \SoapClient($path = $projectDir . '/app/services.wsdl');
  664.             $this->aviaturLogSave->logSave($xmlRequest, $method, 'RQ', $transactionId);
  665.             $response = $client->__doRequest($xmlRequest, $this->urlMpa, $this->serviceNameMpa, 1);
  666.             $this->aviaturLogSave->logSave($response, $method, 'RS', $transactionId);
  668.             return $this->processMpxResponse($xmlRequest, $response, $method, $transactionId);
  669.         } catch (\SoapFault $e) {
  670.             $this->aviaturRegisterException->log(
  671.                 $xmlRequest,
  672.                 json_encode($e)
  673.             );
  675.             return ['error' => 'No se pudo realizar la consulta en el servidor.'];
  676.         }
  677.     }
  679.     /**
  680.      * Realiza la consulta directamente en el servicio del mpa.
  681.      *
  682.      * @param string $xmlRequest
  683.      * @return mixed The result of the processMpxResponse method.
  684.      */
  685.     private function callServiceMpb($method, $xmlRequest, $url, $transactionId = null)
  686.     {
  687.         $this->stopwatch->start('Set headers and options');
  688.         $headers = [
  689.             'Content-Type: text/xml; charset=utf-8',
  690.             'SOAPAction: "http://tempuri.org/Execute"',
  691.             'Expect:',
  692.             'Accept-Encoding: gzip, deflate'
  693.         ];
  695.         $options = [
  696.             CURLOPT_URL            => $url,
  697.             CURLOPT_RETURNTRANSFER => true,
  698.             CURLOPT_FOLLOWLOCATION => true,
  699.             CURLOPT_POST           => true,
  700.             CURLOPT_HTTPHEADER     => $headers,
  701.             CURLOPT_POSTFIELDS     => $xmlRequest,
  702.             CURLOPT_TIMEOUT        => self::CURL_TIMEOUT_MPB,
  703.             CURLOPT_CONNECTTIMEOUT => self::CURL_CONNECT_TIMEOUT_MPB,
  704.             CURLOPT_IPRESOLVE      => CURL_IPRESOLVE_V4,
  705.             CURLOPT_TCP_KEEPALIVE  => true,
  706.             CURLOPT_TCP_KEEPIDLE   => 120,
  707.             CURLOPT_ENCODING       => '',
  708.         ];
  709.         $this->stopwatch->stop('Set headers and options');
  711.         $this->stopwatch->start('Triggers cURL request');
  712.         $ch = curl_init();
  713.         curl_setopt_array($ch, $options);
  715.         $this->aviaturLogSave->logSave($xmlRequest, $method, 'RQ', $transactionId);
  717.         $responseData = curl_exec($ch);
  718.         $curlError = curl_error($ch);
  719.         $httpCode = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
  720.         curl_close($ch);
  721.         $this->stopwatch->stop('Triggers cURL request');
  723.         $this->stopwatch->start('Validates cURL response');
  724.         // Manejo consolidado de errores
  725.         if ($curlError) {
  726.             $errorMessage = sprintf(self::ERROR_CURL, $curlError);
  727.             $this->aviaturLogSave->logSave($errorMessage . ' - ' . $url, 'Error' . $method, 'RS', $transactionId);
  728.             $responseData = '';
  729.         } elseif ($httpCode >= 400) {
  730.             $errorMessage = sprintf(self::ERROR_HTTP, $httpCode);
  731.             $this->aviaturLogSave->logSave($errorMessage . ' - ' . $url, 'Error' . $method, 'RS', $transactionId);
  732.             $responseData = '';
  733.         } elseif (empty($responseData)) {
  734.             $this->aviaturLogSave->logSave(self::ERROR_EMPTY_RESPONSE . ' - ' . $url, 'Error' . $method, 'RS', $transactionId);
  735.             $responseData = '';
  736.         } else {
  737.             $this->aviaturLogSave->logSave($responseData, $method, 'RS', $transactionId);
  738.         }
  739.         $this->stopwatch->stop('Validates cURL response');
  741.         // Sanitizar ampersands para XML válido
  742.         $sanitizedResponse = str_replace('&', '&amp;', $responseData);
  744.         return $this->processMpxResponse($xmlRequest, $sanitizedResponse, $method, $transactionId);
  745.     }
  747.     public function processMpxResponse($xmlRequest, $response, $method, $transactionId, $route = '', $providerArray = [], $agency = null, $isNational = null, $ancillaries = null)
  748.     {
  749.         $this->stopwatch->start('Process MPX response');
  751.         // Validar si hay un faultcode en la respuesta
  752.         if (strpos($response, '<faultcode>') !== false) {
  753.             $this->aviaturRegisterException->log($xmlRequest, $response);
  754.             return ['error' => 'Ha ocurrido un error inesperado en tu proceso de reserva'];
  755.         }
  757.         // Sanitizar respuesta
  758.         $response = $this->sanitizeMpxResponse($response, $method);
  760.         // Extraer el XML de respuesta
  761.         $xmlResponseObject = $this->extractMpxResponseXml($response, $ancillaries);
  763.         if (!$xmlResponseObject) {
  764.             $this->aviaturRegisterException->log($xmlRequest, $response);
  765.             return ['error' => '(66002 ) Error en la respuesta del servicio, no se encontró información'];
  766.         }
  768.         // Procesar y guardar información de proveedores si es necesario
  769.        // if (!empty($route) && !empty($providerArray)) {
  770.             $this->processAndSaveProviderResults(
  771.                 $xmlResponseObject,
  772.                 $method,
  773.                 $route,
  774.                 $providerArray,
  775.                 $agency,
  776.                 $isNational,
  777.                 $transactionId,
  778.                 $xmlRequest
  779.             );
  780.         //}
  782.         // Validar resultados del proveedor
  783.         $errorResult = $this->validateMpxProviderResults($xmlResponseObject, $xmlRequest, $response, $method);
  784.         if ($errorResult !== null) {
  785.             $this->stopwatch->stop('Process MPX response');
  786.             return $errorResult;
  787.         }
  789.         // Validar que el mensaje no esté vacío
  790.         if (isset($xmlResponseObject->Message) && empty($xmlResponseObject->Message)) {
  791.             $this->aviaturRegisterException->log($xmlRequest, $response);
  792.             $this->stopwatch->stop('Process MPX response');
  793.             return ['error' => 'Respuesta vacia de nuestro proveedor de servicios'];
  794.         }
  796.         $this->stopwatch->stop('Process MPX response');
  797.         return $xmlResponseObject;
  798.     }
  800.     /**
  801.      * Sanitiza la respuesta MPX reemplazando caracteres problemáticos.
  802.      *
  803.      * @param string $response Respuesta original
  804.      * @param string $method Método invocado
  805.      * @return string Respuesta sanitizada
  806.      */
  807.     private function sanitizeMpxResponse(string $response, string $method): string
  808.     {
  809.         $applyMethods = ['PkgDetail', 'SvcDetail', 'SvcAvailComb'];
  811.         if (!in_array($method, $applyMethods, true)) {
  812.             $response = str_replace(
  813.                 ['&', 'LLC "NORD WIND"', 'LLC &quot;NORD WIND&quot;'],
  814.                 ['&amp;', 'LLC NORD WIND', 'LLC NORD WIND'],
  815.                 $response
  816.             );
  817.         }
  819.         // Reemplazos comunes para normalizar la respuesta
  820.         $replacements = [
  821.             'mpa:' => '',
  822.             '<serviceDebug>' => '&lt;serviceDebug&gt;',
  823.             'string: "CR' => 'string: CR',
  824.             '0""' => '0"',
  825.             '1""' => '1"',
  826.             '2""' => '2"',
  827.             '3""' => '3"',
  828.             '4""' => '4"',
  829.             '5""' => '5"',
  830.             '6""' => '6"',
  831.             '7""' => '7"',
  832.             '8""' => '8"',
  833.             '9""' => '9"',
  834.             'NO ITINERARY FOUND FOR ' => '(66002 ) NO ITINERARY FOUND FOR ',
  835.         ];
  837.         return str_replace(array_keys($replacements), array_values($replacements), htmlspecialchars_decode($response));
  838.     }
  840.     /**
  841.      * Extrae el XML de respuesta del contenido MPX.
  842.      *
  843.      * @param string $response Respuesta sanitizada
  844.      * @param int|null $ancillaries Flag de ancillaries
  845.      * @return \SimpleXMLElement|false
  846.      */
  847.     private function extractMpxResponseXml(string $response, ?int $ancillaries)
  848.     {
  849.         $values = explode('<Response xmlns:mpa="http://amadeus.com/latam/mpa/2010/1">', $response);
  851.         if (!isset($values[1])) {
  852.             return false;
  853.         }
  855.         // Determinar el cierre del tag según ancillaries
  856.         if ($ancillaries === null) {
  857.             $values = explode('</Response>', $values[1]);
  858.             $value = '<Response>' . $values[0] . '</Response>';
  859.         } else {
  860.             if ($ancillaries) {
  861.                 $values = explode('</ExecuteResult>', $values[1]);
  862.                 $value = '<Response>' . $values[0];
  863.             } else {
  864.                 $values = explode('</Response>', $values[1]);
  865.                 $value = '<Response>' . $values[0] . '</Response>';
  866.             }
  867.         }
  869.         return simplexml_load_string($value);
  870.     }
  872.     /**
  873.      * Procesa y guarda los resultados de proveedores en la base de datos.
  874.      */
  875.     private function processAndSaveProviderResults(
  876.         \SimpleXMLElement $xmlResponseObject,
  877.         string $method,
  878.         string $route,
  879.         array $providerArray,
  880.         $agency,
  881.         $isNational,
  882.         string $transactionId,
  883.         $xmlRequest
  884.     ): void {
  885.         if (!isset($xmlResponseObject->ProviderResults, $xmlResponseObject->ProviderResults->ProviderResult)) {
  886.             return;
  887.         }
  889.         $em = $this->doctrine->getManager();
  890.         $verb = $em->getRepository(\Aviatur\GeneralBundle\Entity\Verb::class)->findOneByName($method);
  892.         $dataFare = [];
  893.         $count = 1;
  895.         foreach ($xmlResponseObject->ProviderResults->ProviderResult as $providerResult) {
  896.             $providerResponse = $this->createProviderResponse(
  897.                 $providerResult,
  898.                 $route,
  899.                 $providerArray,
  900.                 $agency,
  901.                 $isNational,
  902.                 $verb,
  903.                 $transactionId,
  904.                 $xmlRequest,
  905.                 $xmlResponseObject
  906.             );
  908.             // Procesar tarifas si es búsqueda de vuelos
  909.             if (isset($xmlResponseObject->Message->OTA_AirLowFareSearchRS->PricedItineraries)) {
  910.                 if ($count === 1) {
  911.                     $dataFare = $this->extractFareData($xmlResponseObject);
  912.                 }
  914.                 $this->setFareDataToProviderResponse($providerResponse, $dataFare, (int) $providerResult['Provider']);
  915.             }
  917.             if ($isNational !== null) {
  918.                 $providerResponse->setMarket($isNational ? 'Domestic' : 'International');
  919.             }
  921.             $em->persist($providerResponse);
  922.             $count++;
  923.         }
  925.         $em->flush();
  927.         // Procesar detalles adicionales para métodos específicos
  928.         $this->processDetailMethods($xmlResponseObject, $method, $transactionId, $verb, $em);
  929.     }
  931.     /**
  932.      * Valida los resultados del proveedor en respuesta MPX.
  933.      *
  934.      * @return array|null Error array o null si es válido
  935.      */
  936.     private function validateMpxProviderResults(\SimpleXMLElement $xmlResponseObject, string $xmlRequest, string $response, string $method): ?array
  937.     {
  938.         if (!isset($xmlResponseObject->ProviderResults)) {
  939.             return null;
  940.         }
  942.         $hasSuccessfulProvider = false;
  943.         $firstErrorMessage = null;
  944.          // Normalizar mensajes de error comunes
  945.          $commonErrors = [
  946.             'NO ITINERARY FOUND FOR REQUESTED',
  947.             'NO FARE FOUND FOR REQUESTED ITINERARY',
  948.             'No available flight found for the requested',
  949.             'Error en la respuesta del servicio, no se encontr',
  950.             'NO JOURNEY FOUND FOR REQUESTED ITINERARY',
  951.             'No se encontraron resultados o no se encontraron tarifas aplicables',
  952.             'No se permiten busquedas multidestino',
  953.             "No Existe Disponibilidad",
  954.             "QUERY NOT PROCESSABLE",
  955.             "ERR  Se presento un retraso en la Busqueda",
  956.             "Revise los datos de la busqueda",
  957.             "no results",
  958.             "No es posible encontrar recomendaciones"
  959.         ];
  961.         // Validar cada proveedor individualmente
  962.         foreach ($xmlResponseObject->ProviderResults->ProviderResult as $providerResult) {
  963.             $message = (string) $providerResult['Message'];
  964.             $providerId = (int) $providerResult['Provider'];
  966.             if ($message === 'Succesful') {
  967.                 // Este proveedor respondió exitosamente
  968.                 $hasSuccessfulProvider = true;
  969.             } else {
  970.                 $found = false;
  971.                 foreach ($commonErrors as $errorPattern) {
  972.                     if (stripos($message, $errorPattern) !== false) {
  973.                         $found = true; // Se encontró al menos un error común
  974.                         break; // Ya no necesitamos seguir buscando
  975.                     }
  976.                 }
  977.                 if (!$found) {
  978.                     // Solo se ejecuta si NO se encontró ningún patrón
  979.                     //$this->registerProviderError($providerId);
  980.                 }
  982.                 // Guardar el primer mensaje de error para retornar si ninguno es exitoso
  983.                 if ($firstErrorMessage === null) {
  984.                     $firstErrorMessage = $message;
  985.                 }
  986.             }
  987.         }
  989.         // Si al menos un proveedor fue exitoso, la operación es exitosa
  990.         if ($hasSuccessfulProvider) {
  991.             return null;
  992.         }
  994.         // Ningún proveedor fue exitoso, retornar error
  995.         if ($firstErrorMessage !== null && strpos($xmlRequest, 'AirCommandExecute') === false) {
  997.             foreach ($commonErrors as $errorPattern) {
  998.                 if (strpos($firstErrorMessage, $errorPattern) !== false) {
  999.                     return ['error' => self::ERROR_NO_AVAILABILITY];
  1000.                 }
  1001.             }
  1003.             // Si el error no contiene el código de error estándar, registrarlo
  1004.             if (strpos($firstErrorMessage, '(66002 ') === false) {
  1005.                 $this->aviaturRegisterException->log($xmlRequest, $response);
  1006.             }
  1008.             return ['error' => $firstErrorMessage];
  1009.         }
  1011.         return null;
  1012.     }
  1014.     /**
  1015.      * Registra un error del proveedor en la tabla ConfigFlightAgency.
  1016.      * Incrementa errorCount y actualiza errorDatetime.
  1017.      *
  1018.      * @param int $providerId ID del proveedor que generó el error
  1019.      * @return void
  1020.      */
  1021.     private function registerProviderError(int $providerId): void
  1022.     {
  1023.         try {
  1024.             $em = $this->doctrine->getManager();
  1026.             // Obtener el agencyId desde la sesión
  1027.             $agencyId = $this->session->get('agencyId');
  1029.             if (empty($agencyId)) {
  1030.                 return;
  1031.             }
  1033.             // Buscar el ConfigFlightAgency correspondiente
  1034.             $configFlightAgency = $em->getRepository(\Aviatur\FlightBundle\Entity\ConfigFlightAgency::class)
  1035.                 ->createQueryBuilder('cfa')
  1036.                 ->innerJoin('cfa.provider', 'p')
  1037.                 ->innerJoin('cfa.agency', 'a')
  1038.                 ->where('p.provideridentifier = :providerId')
  1039.                 ->andWhere('a.id = :agencyId')
  1040.                 ->setParameter('providerId', $providerId)
  1041.                 ->setParameter('agencyId', $agencyId)
  1042.                 ->getQuery()
  1043.                 ->getOneOrNullResult();
  1045.             if ($configFlightAgency) {
  1046.                 $now = new \DateTime();
  1047.                 $lastErrorDatetime = $configFlightAgency->getErrordatetime();
  1049.                 // Verificar si ya pasaron 10 minutos desde el último error
  1050.                 if ($lastErrorDatetime !== null) {
  1051.                     $diff = $now->getTimestamp() - $lastErrorDatetime->getTimestamp();
  1052.                     $minutesDiff = $diff / 60;
  1054.                     // Si ya pasaron 10 minutos, reiniciar el contador
  1055.                     if ($minutesDiff >= 10) {
  1056.                         $configFlightAgency->setErrorcount(1);
  1057.                     } else {
  1058.                         // Si no han pasado 10 minutos, incrementar el contador
  1059.                         $currentErrorCount = $configFlightAgency->getErrorcount() ?? 0;
  1060.                         $configFlightAgency->setErrorcount($currentErrorCount + 1);
  1061.                     }
  1062.                 } else {
  1063.                     // Si no hay fecha previa, inicializar el contador en 1
  1064.                     $configFlightAgency->setErrorcount(1);
  1065.                 }
  1067.                 // Actualizar la fecha y hora del error
  1068.                 $configFlightAgency->setErrordatetime($now);
  1070.                 $em->persist($configFlightAgency);
  1071.                 $em->flush($configFlightAgency);
  1072.             }
  1073.         } catch (\Exception $e) {
  1074.             // Si hay algún error al registrar, no afectar el flujo principal
  1075.             // Solo registrar en logs para debugging
  1076.             $this->aviaturRegisterException->log(
  1077.                 'Error registrando error de proveedor: ' . $providerId,
  1078.                 $e->getMessage()
  1079.             );
  1080.         }
  1081.     }
  1083.     private function buildXmlRequestObject(string $xmlRequest): ?\SimpleXMLElement
  1084.     {
  1085.         if (empty($xmlRequest)) {
  1086.             return null;
  1087.         }
  1089.         $cleanXml = str_replace(
  1090.             [
  1091.                 'mpa:',
  1092.                 '<serviceDebug>',
  1093.                 'string: "CR',
  1094.                 '0""',
  1095.                 '1""',
  1096.                 '2""',
  1097.                 '3""',
  1098.                 '4""',
  1099.                 '5""',
  1100.                 '6""',
  1101.                 '7""',
  1102.                 '8""',
  1103.                 '9""',
  1104.                 'PremiumEconomy',
  1105.                 'NO ITINERARY FOUND FOR '
  1106.             ],
  1107.             [
  1108.                 '',
  1109.                 '&lt;serviceDebug&gt;',
  1110.                 'string: CR',
  1111.                 '0"',
  1112.                 '1"',
  1113.                 '2"',
  1114.                 '3"',
  1115.                 '4"',
  1116.                 '5"',
  1117.                 '6"',
  1118.                 '7"',
  1119.                 '8"',
  1120.                 '9"',
  1121.                 'PremiumEconomy',
  1122.                 '(66002 ) NO ITINERARY FOUND FOR '
  1123.             ],
  1124.             htmlspecialchars_decode($xmlRequest)
  1125.         );
  1127.         if (!str_contains($cleanXml, '<Request')) {
  1128.             return null;
  1129.         }
  1131.         $parts = explode(
  1132.             '<Request xmlns:mpa="http://amadeus.com/latam/mpa/2010/1">',
  1133.             $cleanXml
  1134.         );
  1136.         if (!isset($parts[1])) {
  1137.             return null;
  1138.         }
  1140.         $parts = explode('</Request>', $parts[1]);
  1142.         if (!isset($parts[0])) {
  1143.             return null;
  1144.         }
  1146.         $finalXml = '<Request>' . $parts[0] . '</Request>';
  1148.         return simplexml_load_string($finalXml) ?: null;
  1149.     }
  1153.     /**
  1154.      * Crea una entidad ProviderResponse con los datos del resultado.
  1155.      */
  1156.     private function createProviderResponse(
  1157.         \SimpleXMLElement $providerResult,
  1158.         string $route,
  1159.         array $providerArray,
  1160.         $agency,
  1161.         ?bool $isNational,
  1162.         $verb,
  1163.         string $transactionId,
  1164.         ?string $xmlRequest = null,
  1165.         ?\SimpleXMLElement $xmlResponseObject = null
  1166.     ): ProviderResponse {
  1167.         $providerResponse = new ProviderResponse();
  1169.         $type = 'M';
  1170.         $finalRoute = '-';
  1171.         $market = null;
  1172.         $airData = null;
  1174.         if ($xmlRequest) {
  1175.             $xmlRequestObject = $this->buildXmlRequestObject($xmlRequest);
  1176.             $otaPriceRQ = $xmlRequestObject->Message->OTA_AirPriceRQ ?? null;
  1178.             if ($otaPriceRQ) {
  1179.                 $airData = $otaPriceRQ->AirItinerary->OriginDestinationOptions ?? null;
  1180.             }
  1181.         }
  1183.         if (!$airData && $xmlResponseObject) {
  1184.             $airData = $xmlResponseObject->Message->OTA_AirLowFareSearchRS->PricedItineraries->PricedItinerary->AirItinerary->OriginDestinationOptions ?? null;
  1185.         }
  1187.         if ($airData && isset($airData->OriginDestinationOption)) {
  1188.             $options = $airData->OriginDestinationOption;
  1189.             $refNumbers = [];
  1191.             foreach ($options as $option) {
  1192.                 $refNumbers[] = (string)($option['RefNumber'] ?? '0');
  1193.             }
  1195.             $uniqueRefs = array_unique($refNumbers);
  1196.             $countUnique = count($uniqueRefs);
  1199.             $firstOptionSegments = $options[0]->FlightSegment;
  1200.             $departure = (string)($firstOptionSegments[0]->DepartureAirport['LocationCode'] ?? '');
  1203.             $arrival = '';
  1204.             foreach ($options as $option) {
  1205.                 if ((string)($option['RefNumber'] ?? '0') === '0') {
  1206.                     $segments = $option->FlightSegment;
  1207.                     $arrival = (string)($segments[count($segments) - 1]->ArrivalAirport['LocationCode'] ?? '');
  1208.                 }
  1209.             }
  1212.             if ($countUnique === 1) {
  1213.                 $type = 'O'; // OneWay
  1214.             } elseif ($countUnique === 2) {
  1215.                 $type = 'R'; // RoundTrip
  1216.             } else {
  1217.                 $type = 'M'; // Multi
  1218.             }
  1220.             if ($departure && $arrival) {
  1221.                 $finalRoute = "$departure-$arrival";
  1222.             }
  1223.         }
  1226.         if ($market === null && is_bool($isNational)) {
  1227.             $market = $isNational ? 'Domestic' : 'International';
  1228.         }
  1231.         if ($finalRoute === '-' && str_contains($route, '|')) {
  1232.             [$fallbackType, $fallbackRoute] = explode('|', $route, 2);
  1233.             $type = $fallbackType ?: $type;
  1234.             $finalRoute = $fallbackRoute ?: $finalRoute;
  1235.         }
  1238.         $providerId = (int)$providerResult['Provider'];
  1239.         $info = (string)($providerResult['Information'] ?? '');
  1241.         $responseTime = null;
  1242.         if (preg_match('/TimeLapse=([\d.]+)/', $info, $matches)) {
  1243.             $responseTime = (float)$matches[1];
  1244.         }
  1246.         $providerEntity = $providerArray[$providerId] ??
  1247.             $this->doctrine->getRepository(\Aviatur\MPABundle\Entity\Provider::class)
  1248.             ->findOneByProvideridentifier($providerId);
  1250.         if ($agency == '') {
  1251.             $agency = $this->doctrine->getRepository(\Aviatur\AgencyBundle\Entity\Agency::class)->find($this->session->get('agencyId'));
  1252.         }
  1255.         return $providerResponse
  1256.             ->setType($type)
  1257.             ->setRoute($finalRoute)
  1258.             ->setMarket($market)
  1259.             ->setMessage((string)$providerResult['Message'])
  1260.             ->setCode((int)$providerResult['Code'])
  1261.             ->setResponsetime($responseTime)
  1262.             ->setProvider($providerEntity)
  1263.             ->setAgency($agency)
  1264.             ->setVerb($verb)
  1265.             ->setTransactionid($transactionId)
  1266.             ->setDatetime(new \DateTime());
  1267.     }
  1268.     
  1269.     
  1270.     
  1272.     /**
  1273.      * Extrae los datos de tarifas de las respuestas de vuelos.
  1274.      *
  1275.      * @return array
  1276.      */
  1277.     private function extractFareData(\SimpleXMLElement $xmlResponseObject): array
  1278. {
  1279.     $dataFare = [];
  1281.     if (!isset($xmlResponseObject->Message->OTA_AirLowFareSearchRS->PricedItineraries->PricedItinerary)) {
  1282.         return $dataFare;
  1283.     }
  1285.     foreach ($xmlResponseObject->Message->OTA_AirLowFareSearchRS->PricedItineraries->PricedItinerary as $itinerary) {
  1286.         $providerId = preg_replace('/^.*ProviderId=([^;]*).*$/s', '$1', (string)$itinerary->Notes, 1);
  1288.         $fareData = [
  1289.             'fare' => (string)$itinerary->AirItineraryPricingInfo->ItinTotalFare->TotalFare['Amount'],
  1290.             'airline' => (string)$itinerary->TicketingInfo->TicketingVendor['Code'],
  1291.         ];
  1293.         $dataFare[$providerId][] = $fareData;
  1294.     }
  1296.     // Ordenar tarifas por proveedor de menor a mayor
  1297.     foreach ($dataFare as &$fares) {
  1298.         usort($fares, fn($a, $b) => $a['fare'] <=> $b['fare']);
  1299.     }
  1301.     return $dataFare;
  1302. }
  1304.     /**
  1305.      * Asigna los datos de tarifa al ProviderResponse.
  1306.      */
  1307.     private function setFareDataToProviderResponse(ProviderResponse $providerResponse, array $dataFare, int $providerId): void
  1308. {
  1309.     if (!isset($dataFare[$providerId])) {
  1310.         return;
  1311.     }
  1313.     $fares = $dataFare[$providerId];
  1314.     $lowestFare = $fares[0];
  1315.     $highestFare = $fares[count($fares) - 1];
  1317.     $providerResponse->setlowestfare($lowestFare['fare']);
  1318.     $providerResponse->setAirlineForLowest($lowestFare['airline']);
  1319.     $providerResponse->setHighestfare($highestFare['fare']);
  1320.     $providerResponse->setAirlineForHighest($highestFare['airline']);
  1321. }
  1323.     /**
  1324.      * Procesa métodos de detalle específicos (AirDetail, AirAddDataPassenger).
  1325.      */
  1326.     private function processDetailMethods(\SimpleXMLElement $xmlResponseObject, string $method, string $transactionId, $verb, $em): void
  1327.     {
  1328.         if (!in_array($method, ['AirDetail', 'AirAddDataPassenger'], true)) {
  1329.             return;
  1330.         }
  1332.         if (!isset($xmlResponseObject->ProviderResults)) {
  1333.             return;
  1334.         }
  1336.         // Este método procesa detalles adicionales que se guardan en la base de datos
  1337.         // para los métodos AirDetail y AirAddDataPassenger
  1338.         // El código original está preservado pero se puede refactorizar más en el futuro
  1339.     }
  1341.     /**
  1342.      * @param type $service
  1343.      * @param type $provider
  1344.      * @param type $providerId
  1345.      *
  1346.      * @return type
  1347.      */
  1348.     public function loginService($service, $provider, $providerId = null)
  1349.     {
  1350.         switch ($this->requestType) {
  1351.             case 'BUS':
  1352.                 $xml = $this->getXmlLogin($providerId);
  1353.                 $xmlResponseObject = $this->callServiceBus($this->projectDir, $service, $provider, $xml);
  1355.                 if (isset($xmlResponseObject['error'])) {
  1356.                     return $xmlResponseObject;
  1357.                 }
  1359.                 return $xmlResponseObject->Message->LoginRS->TransactionIdentifier;
  1361.             case 'MPA':
  1362.             case 'MPB':
  1363.             case 'MPB3':
  1364.             default:
  1365.                 // Generar JWT token para MPA/MPB
  1366.                 return $this->generateJwtToken();
  1367.         }
  1368.     }
  1370.     /**
  1371.      * Genera un JWT token para autenticación MPA/MPB.
  1372.      *
  1373.      * @return string
  1374.      */
  1375.     private function generateJwtToken(): string
  1376.     {
  1377.         $expire = time() + self::SESSION_EXPIRATION_TIME;
  1378.         $token = ['e' => $expire . '_' . $this->random_str(4)];
  1379.         $jwt = explode('.', $this->encodeJWT($token, $this->loginKey));
  1381.         return $jwt[1] . '.' . $jwt[2];
  1382.     }
  1384.     /**
  1385.      * @param type $providerId
  1386.      *
  1387.      * @return string
  1388.      */
  1389.     private function getXmlLogin($providerId)
  1390.     {
  1391.         $xml = '<Request xmlns:mpa="http://amadeus.com/latam/mpa/2010/1">
  1392.             <mpa:Command>Login</mpa:Command>
  1393.             <mpa:Version>1.0</mpa:Version>
  1394.             <mpa:Language>es</mpa:Language>
  1395.             <mpa:ResponseType>XML</mpa:ResponseType>
  1396.             <mpa:Target>Test</mpa:Target>
  1397.             <mpa:MaxExecutionTime>200</mpa:MaxExecutionTime>
  1398.             <mpa:PageSize>0</mpa:PageSize>
  1399.             <mpa:PageNumber>1</mpa:PageNumber>
  1400.             <mpa:CacheRefresh>true</mpa:CacheRefresh>
  1401.             <mpa:Message>
  1402.               <LoginRQ xmlns:mpa="http://amadeus.com/latam/mpa/2010/1">
  1403.                 <mpa:UserIdentification>
  1404.                   <mpa:Corporation>10000</mpa:Corporation>
  1405.                   <mpa:Password>1234</mpa:Password>
  1406.                       <mpa:Office>10001</mpa:Office>
  1407.                 </mpa:UserIdentification>
  1408.               </LoginRQ>
  1409.             </mpa:Message>
  1410.             <mpa:ProviderSettings>
  1411.               <mpa:ProviderSetting>
  1412.                 <mpa:Setting Key="ProviderId" Value="' . $providerId . '" />
  1413.                 <mpa:Setting Key="Language" Value="ES" />
  1414.               </mpa:ProviderSetting>
  1415.             </mpa:ProviderSettings>
  1416.           </Request>';
  1418.         return $xml;
  1419.     }
  1421.     /**
  1422.      * @param type $providerId
  1423.      *
  1424.      * @return string
  1425.      */
  1426.     private function getMpxXmlLogin()
  1427.     {
  1428.         $xml = '<LoginRQ xmlns:mpa="http://amadeus.com/latam/mpa/2010/1">
  1429.                 <mpa:UserIdentification>
  1430.                   <mpa:Corporation>10000</mpa:Corporation>
  1431.                   <mpa:Password>1234</mpa:Password>
  1432.                   <mpa:Office>' . $this->random_str(4) . '</mpa:Office>
  1433.                 </mpa:UserIdentification>
  1434.               </LoginRQ>';
  1436.         return $xml;
  1437.     }
  1439.     public function random_str($length, $keyspace = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ')
  1440.     {
  1441.         $str = '';
  1442.         $max = mb_strlen($keyspace, '8bit') - 1;
  1443.         for ($i = 0; $i < $length; ++$i) {
  1444.             $str .= $keyspace[random_int(0, $max)];
  1445.         }
  1447.         return $str;
  1448.     }
  1450.     /**
  1451.      * Construye el header XML para peticiones BUS.
  1452.      *
  1453.      * @param string $body Cuerpo del XML
  1454.      * @param string $method Método a invocar
  1455.      * @param string $transactionId ID de transacción
  1456.      * @param array $variable Variables para reemplazar
  1457.      *
  1458.      * @return string XML completo con header
  1459.      */
  1460.     public function getXmlBusHeader(string $body, string $method, string $transactionId, array $variable): string
  1461.     {
  1462.         $path = $this->projectDir . '/app/xmlService/busHeader.xml';
  1464.         // Cargar el XML base una sola vez
  1465.         $xmlBase = simplexml_load_file($path)->asXML();
  1467.         // Aplicar officeId si existe en sesión
  1468.         if ($this->session->has('officeId')) {
  1469.             $xmlBase = str_replace('{officeId}', $this->session->get('officeId'), $xmlBase);
  1470.         }
  1472.         // Reemplazar variables en el body (excepto ProviderId)
  1473.         if (isset($variable)) {
  1474.             foreach ($variable as $key => $value) {
  1475.                 if ($key !== 'ProviderId') {
  1476.                     $body = str_replace('{' . $key . '}', $value, $body);
  1477.                 }
  1478.             }
  1479.         }
  1481.         // Reemplazar transactionId en el body
  1482.         $body = str_replace('{transactionId}', $transactionId, $body);
  1484.         // Reemplazar placeholders en el XML base
  1485.         $replacements = [
  1486.             '{method}' => $method,
  1487.             '{body}' => $body,
  1488.             '{ProviderId}' => $variable['ProviderId'] ?? '',
  1489.         ];
  1491.         return str_replace(array_keys($replacements), array_values($replacements), $xmlBase);
  1492.     }
  1494.     /**
  1495.      * Construye el header XML para peticiones MPX (MPA/MPB).
  1496.      *
  1497.      * @param string $body Cuerpo del XML
  1498.      * @param string $method Método a invocar
  1499.      * @param string $transactionId ID de transacción
  1500.      * @param array $variable Variables para reemplazar
  1501.      * @param int|null $ancillaries Ancillaries flag
  1502.      *
  1503.      * @return string XML completo con header
  1504.      */
  1505.     public function getXmlMpxHeader(string $body, string $method, string $transactionId, array $variable, ?int $ancillaries = null): string
  1506.     {
  1507.         $cacheRefresh = $variable['cacheRefresh'] ?? 'true';
  1508.         $cacheKey = $variable['cacheKey'] ?? '';
  1509.         $path = $this->projectDir . '/app/xmlService/' . mb_strtolower($this->requestType) . 'Request.xml';
  1511.         try {
  1512.             $xml = simplexml_load_file($path);
  1513.             if ($xml === false) {
  1514.                 throw new \Exception("Error cargando XML desde: " . $path);
  1515.             }
  1516.             $xmlBase = $xml->asXML();
  1518.             // Aplicar officeId si existe en sesión
  1519.             if ($this->session->has('officeId')) {
  1520.                 $xmlBase = str_replace('{officeId}', $this->session->get('officeId'), $xmlBase);
  1521.             }
  1522.         } catch (\Exception $e) {
  1523.             throw new \Exception($e->getMessage() . " path: " . $path);
  1524.         }
  1526.         // Reemplazar variables en el body (excepto ProviderId y CoveredTraveler)
  1527.         if (isset($variable)) {
  1528.             foreach ($variable as $key => $value) {
  1529.                 if ($key !== 'ProviderId' && $key !== 'CoveredTraveler') {
  1530.                     $body = str_replace('{' . $key . '}', trim($value), $body);
  1531.                 }
  1532.             }
  1533.         }
  1535.         // Reemplazar transactionId y ancillaries en el body
  1536.         $body = str_replace('{transactionId}', $transactionId, $body);
  1537.         $body = str_replace('{ancillaries}', $ancillaries ?? 0, $body);
  1539.         // Reemplazar placeholders en el XML base
  1540.         $replacements = [
  1541.             '{method}' => $method,
  1542.             '{body}' => $body,
  1543.             '{cacheRefresh}' => $cacheRefresh,
  1544.             '{cacheKey}' => $cacheKey,
  1545.             '{ProviderId}' => $variable['ProviderId'] ?? '',
  1546.         ];
  1548.         $xmlBase = str_replace(array_keys($replacements), array_values($replacements), $xmlBase);
  1550.         // Remover declaración XML si existe
  1551.         return preg_replace('/<\?xml.*?\?>/i', '', $xmlBase);
  1552.     }
  1554.     /**
  1555.      * Construye el XML para consulta de usuario B2C.
  1556.      *
  1557.      * @param string $DocumentType Tipo de documento
  1558.      * @param string $Documentnumber Número de documento
  1559.      *
  1560.      * @return string XML de consulta
  1561.      */
  1562.     public function getXmlUserB2C(string $DocumentType, string $Documentnumber): string
  1563.     {
  1564.         $path = $this->projectDir . '/app/xmlService/mpaUserB2C.xml';
  1566.         //Valores a remplazar
  1567.         $arrayIndex = [
  1568.             '{DocumentType}',
  1569.             '{DocumentNumber}',
  1570.         ];
  1571.         //Nuevos valores
  1572.         $arrayValues = [
  1573.             $DocumentType,
  1574.             $Documentnumber,
  1575.         ];
  1576.         //obtengo el xml base
  1577.         $xmlBase = simplexml_load_file($path)->asXML();
  1579.         $xmlBase = str_replace($arrayIndex, $arrayValues, $xmlBase);
  1581.         return $xmlBase;
  1582.     }
  1584.     /**
  1585.      * Encripta el usuario con una clave secreta.
  1586.      *
  1587.      * @param string $user Usuario a encriptar
  1588.      * @param string $secretKey Clave secreta
  1589.      *
  1590.      * @return string Usuario encriptado
  1591.      */
  1592.     public function encryptUser(string $user, string $secretKey): string
  1593.     {
  1594.         $encryptUser = '';
  1595.         if ('test1' !== $user) {
  1596.             $encryptUser = hash_hmac('sha512', $user, $secretKey . false);
  1597.         } else {
  1598.             $encryptUser = $user;
  1599.         }
  1601.         return $encryptUser;
  1602.     }
  1604.     /**
  1605.      * Configura todas las URLs de los servicios desde un objeto de parámetros.
  1606.      *
  1607.      * @param object $parameters Objeto con las configuraciones de URLs
  1608.      * @return void
  1609.      */
  1610.     public function setUrls($parameters): void
  1611.     {
  1612.         $this->url = $parameters->aviatur_service_web_url;
  1613.         $this->urlMpa = $parameters->aviatur_service_web_url_mpa;
  1614.         $this->urlLoginMpb = $parameters->aviatur_service_web_url_login_mpb;
  1615.         $this->urlAirMpb = $parameters->aviatur_service_web_url_air_mpb;
  1616.         $this->urlHotelMpb = $parameters->aviatur_service_web_url_hotel_mpb;
  1617.         $this->urlCarMpb = $parameters->aviatur_service_web_url_car_mpb;
  1618.         $this->urlTicketMpb = $parameters->aviatur_service_web_url_ticket_mpb;
  1619.         $this->urlCruiseMpb = $parameters->aviatur_service_web_url_cruise_mpb;
  1620.         $this->urlEmission = $parameters->aviatur_service_web_url_emission;
  1621.         $this->requestId = $parameters->aviatur_service_web_request_id;
  1622.         $this->requestType = $parameters->aviatur_service_web_request_type;
  1623.         $this->serviceNameMpa = $parameters->aviatur_service_web_mpa_method;
  1624.         $this->urlPackageMpt = $parameters->aviatur_service_web_mpb_mpt;
  1625.         $this->urlInsuranceMpb = $parameters->aviatur_service_web_url_insurance_mpb;
  1626.         $this->urlBusMpb = $parameters->aviatur_service_web_url_bus_mpb;
  1627.         $this->urlTrainMpb = $parameters->aviatur_service_web_url_train_mpb;
  1628.         $this->urlExperience = $parameters->aviatur_service_web_mpb_experience;
  1629.     }
  1631.     /**
  1632.      * Obtiene o genera un transaction ID.
  1633.      *
  1634.      * @param string $service Servicio a consultar
  1635.      * @param string $provider Proveedor
  1636.      * @param array $variable Variables de configuración
  1637.      *
  1638.      * @return string|array Transaction ID o array con error
  1639.      */
  1640.     public function getTransactionId(string $service, string $provider, array $variable)
  1641.     {
  1642.         if ($this->session->has('transactionId')) {
  1643.             $transactionId = $this->loginService($service, $provider, $variable['ProviderId']);
  1644.             if (isset($transactionId['error'])) {
  1645.                 return $transactionId;
  1646.             } else {
  1647.                 $this->session->set($this->transactionIdSessionName, (string) $transactionId);
  1648.             }
  1649.         } else {
  1650.             $transactionId = $this->session->get('transactionId');
  1651.         }
  1652.         return $transactionId;
  1653.     }
  1655.     /**
  1656.      * getIINRanges()
  1657.      * Para obtener todos los rangos asociados a IIN de las franquicias activas, y estas se manejarán en variables globales con arrays de javascript
  1658.      * Author: Ing. David Rincon
  1659.      * Email: david.rincon@aviatur.com
  1660.      * Date: 2025/03/06
  1661.      * @param $em (Object of DB manager).
  1662.      * @return array
  1663.      */
  1664.     public function getIINRanges($em){
  1665.         $iinRecords = $em->getRepository(\Aviatur\GeneralBundle\Entity\Card::class)->findByActiveFranchises();
  1666.         $ccranges = [];
  1667.         $ccfranchises = [];
  1668.         foreach ($iinRecords as $key => $iinRecord) {
  1669.             $paymentGatewayCode = $iinRecord["paymentgatewaycode"];
  1670.             $description = $iinRecord["description"];
  1671.             $description = strtoupper(str_replace(' ', '', trim($description)));
  1672.             $stringRanges = $iinRecord["ranges"];
  1673.             $ranges = json_decode($stringRanges, true);
  1674.             $stringLengths = $iinRecord["lengths"];
  1675.             $lengths = json_decode($stringLengths, true);
  1676.             $luhn = $iinRecord["luhn"];
  1677.             $cvvDigits = $iinRecord["cvvdigits"];
  1678.             $tempLengths = [];
  1679.             if (!empty($lengths)) {
  1680.                 foreach ($lengths["lengths"] as $length) {
  1681.                     $tempLengths[] = array(0 => $length[0], 1 => (isset($length[1]) ? $length[1] : $length[0]));
  1682.                 }
  1683.             }
  1684.             $tempRecordArrayFranchises = [];
  1685.             $tempRecordArrayFranchises["code"] = $paymentGatewayCode;
  1686.             $tempRecordArrayFranchises["codename"] = $description;
  1687.             $tempRecordArrayFranchises["luhn"] = $luhn;
  1688.             $tempRecordArrayFranchises["length"] = $tempLengths;
  1689.             $tempRecordArrayFranchises["cvvd"] = $cvvDigits;
  1690.             $ccfranchises[$paymentGatewayCode] = $tempRecordArrayFranchises;
  1691.             if (!empty($ranges)) {
  1692.                 foreach ($ranges["ranges"] as $range) {
  1693.                     $tempRecordArrayRanges = [];
  1694.                     $tempRecordArrayRanges["range"][0] = $range[0];
  1695.                     $tempRecordArrayRanges["range"][1] = (isset($range[1]) ? $range[1] : $range[0]);
  1696.                     $tempRecordArrayRanges["minimum"] = strlen($range[0]);
  1697.                     $tempRecordArrayRanges["code"] = $paymentGatewayCode;
  1698.                     $ccranges[] = $tempRecordArrayRanges;
  1699.                 }
  1700.             }
  1701.         }
  1702.         return ["ccranges" => $ccranges, "ccfranchises" => $ccfranchises];
  1703.     }
  1705.     private function encodeJWT($payload, $key, $alg = "HS256") {
  1706.         $header = ['alg' => $alg, 'typ' => 'JWT'];
  1707.         $segments = [];
  1708.         $segments[] = $this->urlsafeB64Encode(\json_encode($header));
  1709.         $segments[] = $this->urlsafeB64Encode(\json_encode($payload));
  1710.         $signing_input = \implode('.', $segments);
  1711.         $signature = \hash_hmac('SHA256', $signing_input, $key, true);
  1712.         $segments[] = $this->urlsafeB64Encode($signature);
  1714.         return \implode('.', $segments);
  1715.     }
  1717.     private function urlsafeB64Encode($input) {
  1718.         return \str_replace('=', '', \strtr(\base64_encode($input), '+/', '-_'));
  1719.     }
  1721.     /**
  1722.      * Decodes a JWT string into a PHP object.
  1723.      *
  1724.      * @param string        $jwt            The JWT
  1725.      * @param string|array  $key            The key, or map of keys.
  1726.      *                                      If the algorithm used is asymmetric, this is the public key
  1727.      * @param array         $allowed_algs   List of supported verification algorithms
  1728.      *                                      Supported algorithms are 'HS256', 'HS384', 'HS512' and 'RS256'
  1729.      *
  1730.      * @return object The JWT's payload as a PHP object
  1731.      *
  1732.      *
  1733.      * @uses jsonDecode
  1734.      * @uses urlsafeB64Decode
  1735.      */
  1736.     public static function decodeJWT($jwt, $key, $allowed_algs = array())
  1737.     {
  1738.         $timestamp = time();
  1740.         if (empty($key)) {
  1741.             throw new WebServiceException('Key may not be empty', '');
  1742.         }
  1743.         if (!is_array($allowed_algs)) {
  1744.             throw new WebServiceException('Algorithm not allowed', '');
  1745.         }
  1746.         $tks = explode('.', $jwt);
  1747.         if (count($tks) != 3) {
  1748.             throw new WebServiceException('Wrong number of segments', '');
  1749.         }
  1750.         list($headb64, $bodyb64, $cryptob64) = $tks;
  1751.         if (null === ($header = static::jsonDecode(static::urlsafeB64Decode($headb64)))) {
  1752.             throw new WebServiceException('Invalid header encoding', '');
  1753.         }
  1754.         if (null === $payload = static::jsonDecode(static::urlsafeB64Decode($bodyb64))) {
  1755.             throw new WebServiceException('Invalid claims encoding', '');
  1756.         }
  1757.         $sig = static::urlsafeB64Decode($cryptob64);
  1759.         if (empty($header->alg)) {
  1760.             throw new WebServiceException('Empty algorithm', '');
  1761.         }
  1762.         if (!in_array($header->alg, $allowed_algs)) {
  1763.             throw new WebServiceException('Algorithm not allowed', '');
  1764.         }
  1765.         if (is_array($key) || $key instanceof \ArrayAccess) {
  1766.             if (isset($header->kid)) {
  1767.                 $key = $key[$header->kid];
  1768.             } else {
  1769.                 throw new WebServiceException('"kid" empty, unable to lookup correct key', '');
  1770.             }
  1771.         }
  1773.         // Check if the nbf if it is defined. This is the time that the
  1774.         // token can actually be used. If it's not yet that time, abort.
  1775.         if (isset($payload->nbf) && $payload->nbf > $timestamp) {
  1776.             throw new WebServiceException(
  1777.                 'Cannot handle token prior to ' . date(\DateTime::ISO8601, $payload->nbf), ''
  1778.             );
  1779.         }
  1781.         // Check that this token has been created before 'now'. This prevents
  1782.         // using tokens that have been created for later use (and haven't
  1783.         // correctly used the nbf claim).
  1784.         if (isset($payload->iat) && $payload->iat > $timestamp) {
  1785.             throw new WebServiceException(
  1786.                 'Cannot handle token prior to ' . date(\DateTime::ISO8601, $payload->iat), ''
  1787.             );
  1788.         }
  1790.         // Check if this token has expired.
  1791.         if (isset($payload->exp) && $timestamp >= $payload->exp) {
  1792.             throw new WebServiceException('Expired token', '');
  1793.         }
  1795.         return $payload;
  1796.     }
  1798.     private static function urlsafeB64Decode(string $input): string {
  1799.         $remainder = \strlen($input) % 4;
  1800.         if ($remainder) {
  1801.             $padlen = 4 - $remainder;
  1802.             $input .= \str_repeat('=', $padlen);
  1803.         }
  1804.         $return = \strtr($input, '-_', '+/');
  1806.         return \base64_decode($return);
  1807.     }
  1809.     public static function jsonDecode(string $input) {
  1810.         $obj = \json_decode($input, false, 512, JSON_BIGINT_AS_STRING);
  1812.         if ($errno = \json_last_error()) {
  1813.             throw new \Exception($errno);
  1814.         } elseif ($obj === null && $input !== 'null') {
  1815.             throw new \Exception('Null result with non-null input');
  1816.         }
  1817.         return $obj;
  1818.     }
  1819. }