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

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.             );
  779.         }
  781.         // Validar resultados del proveedor
  782.         $errorResult = $this->validateMpxProviderResults($xmlResponseObject, $xmlRequest, $response, $method);
  783.         if ($errorResult !== null) {
  784.             $this->stopwatch->stop('Process MPX response');
  785.             return $errorResult;
  786.         }
  788.         // Validar que el mensaje no esté vacío
  789.         if (isset($xmlResponseObject->Message) && empty($xmlResponseObject->Message)) {
  790.             $this->aviaturRegisterException->log($xmlRequest, $response);
  791.             $this->stopwatch->stop('Process MPX response');
  792.             return ['error' => 'Respuesta vacia de nuestro proveedor de servicios'];
  793.         }
  795.         $this->stopwatch->stop('Process MPX response');
  796.         return $xmlResponseObject;
  797.     }
  799.     /**
  800.      * Sanitiza la respuesta MPX reemplazando caracteres problemáticos.
  801.      *
  802.      * @param string $response Respuesta original
  803.      * @param string $method Método invocado
  804.      * @return string Respuesta sanitizada
  805.      */
  806.     private function sanitizeMpxResponse(string $response, string $method): string
  807.     {
  808.         $applyMethods = ['PkgDetail', 'SvcDetail', 'SvcAvailComb'];
  810.         if (!in_array($method, $applyMethods, true)) {
  811.             $response = str_replace(
  812.                 ['&', 'LLC "NORD WIND"', 'LLC &quot;NORD WIND&quot;'],
  813.                 ['&amp;', 'LLC NORD WIND', 'LLC NORD WIND'],
  814.                 $response
  815.             );
  816.         }
  818.         // Reemplazos comunes para normalizar la respuesta
  819.         $replacements = [
  820.             'mpa:' => '',
  821.             '<serviceDebug>' => '&lt;serviceDebug&gt;',
  822.             'string: "CR' => 'string: CR',
  823.             '0""' => '0"',
  824.             '1""' => '1"',
  825.             '2""' => '2"',
  826.             '3""' => '3"',
  827.             '4""' => '4"',
  828.             '5""' => '5"',
  829.             '6""' => '6"',
  830.             '7""' => '7"',
  831.             '8""' => '8"',
  832.             '9""' => '9"',
  833.             'NO ITINERARY FOUND FOR ' => '(66002 ) NO ITINERARY FOUND FOR ',
  834.         ];
  836.         return str_replace(array_keys($replacements), array_values($replacements), htmlspecialchars_decode($response));
  837.     }
  839.     /**
  840.      * Extrae el XML de respuesta del contenido MPX.
  841.      *
  842.      * @param string $response Respuesta sanitizada
  843.      * @param int|null $ancillaries Flag de ancillaries
  844.      * @return \SimpleXMLElement|false
  845.      */
  846.     private function extractMpxResponseXml(string $response, ?int $ancillaries)
  847.     {
  848.         $values = explode('<Response xmlns:mpa="http://amadeus.com/latam/mpa/2010/1">', $response);
  850.         if (!isset($values[1])) {
  851.             return false;
  852.         }
  854.         // Determinar el cierre del tag según ancillaries
  855.         if ($ancillaries === null) {
  856.             $values = explode('</Response>', $values[1]);
  857.             $value = '<Response>' . $values[0] . '</Response>';
  858.         } else {
  859.             if ($ancillaries) {
  860.                 $values = explode('</ExecuteResult>', $values[1]);
  861.                 $value = '<Response>' . $values[0];
  862.             } else {
  863.                 $values = explode('</Response>', $values[1]);
  864.                 $value = '<Response>' . $values[0] . '</Response>';
  865.             }
  866.         }
  868.         return simplexml_load_string($value);
  869.     }
  871.     /**
  872.      * Procesa y guarda los resultados de proveedores en la base de datos.
  873.      */
  874.     private function processAndSaveProviderResults(
  875.         \SimpleXMLElement $xmlResponseObject,
  876.         string $method,
  877.         string $route,
  878.         array $providerArray,
  879.         $agency,
  880.         $isNational,
  881.         string $transactionId
  882.     ): void {
  883.         if (!isset($xmlResponseObject->ProviderResults, $xmlResponseObject->ProviderResults->ProviderResult)) {
  884.             return;
  885.         }
  887.         $em = $this->doctrine->getManager();
  888.         $verb = $em->getRepository(\Aviatur\GeneralBundle\Entity\Verb::class)->findOneByName($method);
  890.         $dataFare = [];
  891.         $count = 1;
  893.         foreach ($xmlResponseObject->ProviderResults->ProviderResult as $providerResult) {
  894.             $providerResponse = $this->createProviderResponse(
  895.                 $providerResult,
  896.                 $route,
  897.                 $providerArray,
  898.                 $agency,
  899.                 $isNational,
  900.                 $verb,
  901.                 $transactionId
  902.             );
  904.             // Procesar tarifas si es búsqueda de vuelos
  905.             if (isset($xmlResponseObject->Message->OTA_AirLowFareSearchRS->PricedItineraries)) {
  906.                 if ($count === 1) {
  907.                     $dataFare = $this->extractFareData($xmlResponseObject);
  908.                 }
  910.                 $this->setFareDataToProviderResponse($providerResponse, $dataFare, (int) $providerResult['Provider']);
  911.             }
  913.             if ($isNational !== null) {
  914.                 $providerResponse->setMarket($isNational ? 'Domestic' : 'International');
  915.             }
  917.             $em->persist($providerResponse);
  918.             $count++;
  919.         }
  921.         $em->flush();
  923.         // Procesar detalles adicionales para métodos específicos
  924.         $this->processDetailMethods($xmlResponseObject, $method, $transactionId, $verb, $em);
  925.     }
  927.     /**
  928.      * Valida los resultados del proveedor en respuesta MPX.
  929.      *
  930.      * @return array|null Error array o null si es válido
  931.      */
  932.     private function validateMpxProviderResults(\SimpleXMLElement $xmlResponseObject, string $xmlRequest, string $response, string $method): ?array
  933.     {
  934.         if (!isset($xmlResponseObject->ProviderResults)) {
  935.             return null;
  936.         }
  938.         $hasSuccessfulProvider = false;
  939.         $firstErrorMessage = null;
  940.          // Normalizar mensajes de error comunes
  941.          $commonErrors = [
  942.             'NO ITINERARY FOUND FOR REQUESTED',
  943.             'NO FARE FOUND FOR REQUESTED ITINERARY',
  944.             'No available flight found for the requested',
  945.             'Error en la respuesta del servicio, no se encontr',
  946.             'NO JOURNEY FOUND FOR REQUESTED ITINERARY',
  947.             'No se encontraron resultados o no se encontraron tarifas aplicables',
  948.             'No se permiten busquedas multidestino',
  949.             "No Existe Disponibilidad",
  950.             "QUERY NOT PROCESSABLE",
  951.             "ERR  Se presento un retraso en la Busqueda",
  952.             "Revise los datos de la busqueda",
  953.             "no results",
  954.             "No es posible encontrar recomendaciones"
  955.         ];
  957.         // Validar cada proveedor individualmente
  958.         foreach ($xmlResponseObject->ProviderResults->ProviderResult as $providerResult) {
  959.             $message = (string) $providerResult['Message'];
  960.             $providerId = (int) $providerResult['Provider'];
  962.             if ($message === 'Succesful') {
  963.                 // Este proveedor respondió exitosamente
  964.                 $hasSuccessfulProvider = true;
  965.             } else {
  966.                 $found = false;
  967.                 foreach ($commonErrors as $errorPattern) {
  968.                     if (stripos($message, $errorPattern) !== false) {
  969.                         $found = true; // Se encontró al menos un error común
  970.                         break; // Ya no necesitamos seguir buscando
  971.                     }
  972.                 }
  973.                 if (!$found) {
  974.                     // Solo se ejecuta si NO se encontró ningún patrón
  975.                     //$this->registerProviderError($providerId);
  976.                 }
  978.                 // Guardar el primer mensaje de error para retornar si ninguno es exitoso
  979.                 if ($firstErrorMessage === null) {
  980.                     $firstErrorMessage = $message;
  981.                 }
  982.             }
  983.         }
  985.         // Si al menos un proveedor fue exitoso, la operación es exitosa
  986.         if ($hasSuccessfulProvider) {
  987.             return null;
  988.         }
  990.         // Ningún proveedor fue exitoso, retornar error
  991.         if ($firstErrorMessage !== null && strpos($xmlRequest, 'AirCommandExecute') === false) {
  993.             foreach ($commonErrors as $errorPattern) {
  994.                 if (strpos($firstErrorMessage, $errorPattern) !== false) {
  995.                     return ['error' => self::ERROR_NO_AVAILABILITY];
  996.                 }
  997.             }
  999.             // Si el error no contiene el código de error estándar, registrarlo
  1000.             if (strpos($firstErrorMessage, '(66002 ') === false) {
  1001.                 $this->aviaturRegisterException->log($xmlRequest, $response);
  1002.             }
  1004.             return ['error' => $firstErrorMessage];
  1005.         }
  1007.         return null;
  1008.     }
  1010.     /**
  1011.      * Registra un error del proveedor en la tabla ConfigFlightAgency.
  1012.      * Incrementa errorCount y actualiza errorDatetime.
  1013.      *
  1014.      * @param int $providerId ID del proveedor que generó el error
  1015.      * @return void
  1016.      */
  1017.     private function registerProviderError(int $providerId): void
  1018.     {
  1019.         try {
  1020.             $em = $this->doctrine->getManager();
  1022.             // Obtener el agencyId desde la sesión
  1023.             $agencyId = $this->session->get('agencyId');
  1025.             if (empty($agencyId)) {
  1026.                 return;
  1027.             }
  1029.             // Buscar el ConfigFlightAgency correspondiente
  1030.             $configFlightAgency = $em->getRepository(\Aviatur\FlightBundle\Entity\ConfigFlightAgency::class)
  1031.                 ->createQueryBuilder('cfa')
  1032.                 ->innerJoin('cfa.provider', 'p')
  1033.                 ->innerJoin('cfa.agency', 'a')
  1034.                 ->where('p.provideridentifier = :providerId')
  1035.                 ->andWhere('a.id = :agencyId')
  1036.                 ->setParameter('providerId', $providerId)
  1037.                 ->setParameter('agencyId', $agencyId)
  1038.                 ->getQuery()
  1039.                 ->getOneOrNullResult();
  1041.             if ($configFlightAgency) {
  1042.                 $now = new \DateTime();
  1043.                 $lastErrorDatetime = $configFlightAgency->getErrordatetime();
  1045.                 // Verificar si ya pasaron 10 minutos desde el último error
  1046.                 if ($lastErrorDatetime !== null) {
  1047.                     $diff = $now->getTimestamp() - $lastErrorDatetime->getTimestamp();
  1048.                     $minutesDiff = $diff / 60;
  1050.                     // Si ya pasaron 10 minutos, reiniciar el contador
  1051.                     if ($minutesDiff >= 10) {
  1052.                         $configFlightAgency->setErrorcount(1);
  1053.                     } else {
  1054.                         // Si no han pasado 10 minutos, incrementar el contador
  1055.                         $currentErrorCount = $configFlightAgency->getErrorcount() ?? 0;
  1056.                         $configFlightAgency->setErrorcount($currentErrorCount + 1);
  1057.                     }
  1058.                 } else {
  1059.                     // Si no hay fecha previa, inicializar el contador en 1
  1060.                     $configFlightAgency->setErrorcount(1);
  1061.                 }
  1063.                 // Actualizar la fecha y hora del error
  1064.                 $configFlightAgency->setErrordatetime($now);
  1066.                 $em->persist($configFlightAgency);
  1067.                 $em->flush($configFlightAgency);
  1068.             }
  1069.         } catch (\Exception $e) {
  1070.             // Si hay algún error al registrar, no afectar el flujo principal
  1071.             // Solo registrar en logs para debugging
  1072.             $this->aviaturRegisterException->log(
  1073.                 'Error registrando error de proveedor: ' . $providerId,
  1074.                 $e->getMessage()
  1075.             );
  1076.         }
  1077.     }
  1079.     /**
  1080.      * Crea una entidad ProviderResponse con los datos del resultado.
  1081.      */
  1082.     private function createProviderResponse(
  1083.         \SimpleXMLElement $providerResult,
  1084.         string $route,
  1085.         array $providerArray,
  1086.         $agency,
  1087.         $isNational,
  1088.         $verb,
  1089.         string $transactionId
  1090.     ): ProviderResponse {
  1091.         $routeParts = explode('|', $route);
  1092.         $providerResponse = new ProviderResponse();
  1094.         $providerResponse->setType($routeParts[0]);
  1095.         $providerResponse->setRoute($routeParts[1]);
  1096.         $providerResponse->setMessage((string) $providerResult['Message']);
  1097.         $providerResponse->setCode((int) $providerResult['Code']);
  1099.         $information = (string) $providerResult['Information'];
  1100.         if (strpos($information, 'TimeLapse=') !== false) {
  1101.             $timeLapse = explode('TimeLapse=', $information)[1];
  1102.             $providerResponse->setResponsetime((float) $timeLapse);
  1103.         }
  1105.         $providerResponse->setProvider($providerArray[(int) $providerResult['Provider']]);
  1106.         $providerResponse->setAgency($agency);
  1107.         $providerResponse->setVerb($verb);
  1108.         $providerResponse->setTransactionid($transactionId);
  1109.         $providerResponse->setDatetime(new \DateTime());
  1111.         return $providerResponse;
  1112.     }
  1114.     /**
  1115.      * Extrae los datos de tarifas de las respuestas de vuelos.
  1116.      *
  1117.      * @return array
  1118.      */
  1119.     private function extractFareData(\SimpleXMLElement $xmlResponseObject): array
  1120.     {
  1121.         $dataFare = [];
  1122.         $providersSuccessful = [];
  1124.         foreach ($xmlResponseObject->Message->OTA_AirLowFareSearchRS->PricedItineraries->PricedItinerary as $pricedItinerary) {
  1125.             $providerId = preg_replace('/^.*ProviderId=([^;]*).*$/s', '$1', (string) $pricedItinerary->Notes, 1);
  1127.             if (!in_array($providerId, $providersSuccessful, true)) {
  1128.                 $providersSuccessful[] = $providerId;
  1129.             }
  1131.             $fareData = [
  1132.                 'fare' => (string) $pricedItinerary->AirItineraryPricingInfo->ItinTotalFare->TotalFare['Amount'],
  1133.                 'airline' => (string) $pricedItinerary->TicketingInfo->TicketingVendor['Code'],
  1134.             ];
  1136.             $dataFare[$providerId][] = $fareData;
  1137.         }
  1139.         // Ordenar tarifas por proveedor
  1140.         foreach ($providersSuccessful as $providerId) {
  1141.             if (isset($dataFare[$providerId])) {
  1142.                 usort($dataFare[$providerId], function($a, $b) {
  1143.                     return $a['fare'] <=> $b['fare'];
  1144.                 });
  1145.             }
  1146.         }
  1148.         return $dataFare;
  1149.     }
  1151.     /**
  1152.      * Asigna los datos de tarifa al ProviderResponse.
  1153.      */
  1154.     private function setFareDataToProviderResponse(ProviderResponse $providerResponse, array $dataFare, int $providerId): void
  1155.     {
  1156.         if (!isset($dataFare[$providerId])) {
  1157.             return;
  1158.         }
  1160.         $fares = $dataFare[$providerId];
  1161.         $lowestFare = $fares[0];
  1162.         $highestFare = $fares[count($fares) - 1];
  1164.         $providerResponse->setlowestfare($lowestFare['fare']);
  1165.         $providerResponse->setAirlineForLowest($lowestFare['airline']);
  1166.         $providerResponse->setHighestfare($highestFare['fare']);
  1167.         $providerResponse->setAirlineForHighest($highestFare['airline']);
  1168.     }
  1170.     /**
  1171.      * Procesa métodos de detalle específicos (AirDetail, AirAddDataPassenger).
  1172.      */
  1173.     private function processDetailMethods(\SimpleXMLElement $xmlResponseObject, string $method, string $transactionId, $verb, $em): void
  1174.     {
  1175.         if (!in_array($method, ['AirDetail', 'AirAddDataPassenger'], true)) {
  1176.             return;
  1177.         }
  1179.         if (!isset($xmlResponseObject->ProviderResults)) {
  1180.             return;
  1181.         }
  1183.         // Este método procesa detalles adicionales que se guardan en la base de datos
  1184.         // para los métodos AirDetail y AirAddDataPassenger
  1185.         // El código original está preservado pero se puede refactorizar más en el futuro
  1186.     }
  1188.     /**
  1189.      * @param type $service
  1190.      * @param type $provider
  1191.      * @param type $providerId
  1192.      *
  1193.      * @return type
  1194.      */
  1195.     public function loginService($service, $provider, $providerId = null)
  1196.     {
  1197.         switch ($this->requestType) {
  1198.             case 'BUS':
  1199.                 $xml = $this->getXmlLogin($providerId);
  1200.                 $xmlResponseObject = $this->callServiceBus($this->projectDir, $service, $provider, $xml);
  1202.                 if (isset($xmlResponseObject['error'])) {
  1203.                     return $xmlResponseObject;
  1204.                 }
  1206.                 return $xmlResponseObject->Message->LoginRS->TransactionIdentifier;
  1208.             case 'MPA':
  1209.             case 'MPB':
  1210.             case 'MPB3':
  1211.             default:
  1212.                 // Generar JWT token para MPA/MPB
  1213.                 return $this->generateJwtToken();
  1214.         }
  1215.     }
  1217.     /**
  1218.      * Genera un JWT token para autenticación MPA/MPB.
  1219.      *
  1220.      * @return string
  1221.      */
  1222.     private function generateJwtToken(): string
  1223.     {
  1224.         $expire = time() + self::SESSION_EXPIRATION_TIME;
  1225.         $token = ['e' => $expire . '_' . $this->random_str(4)];
  1226.         $jwt = explode('.', $this->encodeJWT($token, $this->loginKey));
  1228.         return $jwt[1] . '.' . $jwt[2];
  1229.     }
  1231.     /**
  1232.      * @param type $providerId
  1233.      *
  1234.      * @return string
  1235.      */
  1236.     private function getXmlLogin($providerId)
  1237.     {
  1238.         $xml = '<Request xmlns:mpa="http://amadeus.com/latam/mpa/2010/1">
  1239.             <mpa:Command>Login</mpa:Command>
  1240.             <mpa:Version>1.0</mpa:Version>
  1241.             <mpa:Language>es</mpa:Language>
  1242.             <mpa:ResponseType>XML</mpa:ResponseType>
  1243.             <mpa:Target>Test</mpa:Target>
  1244.             <mpa:MaxExecutionTime>200</mpa:MaxExecutionTime>
  1245.             <mpa:PageSize>0</mpa:PageSize>
  1246.             <mpa:PageNumber>1</mpa:PageNumber>
  1247.             <mpa:CacheRefresh>true</mpa:CacheRefresh>
  1248.             <mpa:Message>
  1249.               <LoginRQ xmlns:mpa="http://amadeus.com/latam/mpa/2010/1">
  1250.                 <mpa:UserIdentification>
  1251.                   <mpa:Corporation>10000</mpa:Corporation>
  1252.                   <mpa:Password>1234</mpa:Password>
  1253.                       <mpa:Office>10001</mpa:Office>
  1254.                 </mpa:UserIdentification>
  1255.               </LoginRQ>
  1256.             </mpa:Message>
  1257.             <mpa:ProviderSettings>
  1258.               <mpa:ProviderSetting>
  1259.                 <mpa:Setting Key="ProviderId" Value="' . $providerId . '" />
  1260.                 <mpa:Setting Key="Language" Value="ES" />
  1261.               </mpa:ProviderSetting>
  1262.             </mpa:ProviderSettings>
  1263.           </Request>';
  1265.         return $xml;
  1266.     }
  1268.     /**
  1269.      * @param type $providerId
  1270.      *
  1271.      * @return string
  1272.      */
  1273.     private function getMpxXmlLogin()
  1274.     {
  1275.         $xml = '<LoginRQ xmlns:mpa="http://amadeus.com/latam/mpa/2010/1">
  1276.                 <mpa:UserIdentification>
  1277.                   <mpa:Corporation>10000</mpa:Corporation>
  1278.                   <mpa:Password>1234</mpa:Password>
  1279.                   <mpa:Office>' . $this->random_str(4) . '</mpa:Office>
  1280.                 </mpa:UserIdentification>
  1281.               </LoginRQ>';
  1283.         return $xml;
  1284.     }
  1286.     public function random_str($length, $keyspace = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ')
  1287.     {
  1288.         $str = '';
  1289.         $max = mb_strlen($keyspace, '8bit') - 1;
  1290.         for ($i = 0; $i < $length; ++$i) {
  1291.             $str .= $keyspace[random_int(0, $max)];
  1292.         }
  1294.         return $str;
  1295.     }
  1297.     /**
  1298.      * Construye el header XML para peticiones BUS.
  1299.      *
  1300.      * @param string $body Cuerpo del XML
  1301.      * @param string $method Método a invocar
  1302.      * @param string $transactionId ID de transacción
  1303.      * @param array $variable Variables para reemplazar
  1304.      *
  1305.      * @return string XML completo con header
  1306.      */
  1307.     public function getXmlBusHeader(string $body, string $method, string $transactionId, array $variable): string
  1308.     {
  1309.         $path = $this->projectDir . '/app/xmlService/busHeader.xml';
  1311.         // Cargar el XML base una sola vez
  1312.         $xmlBase = simplexml_load_file($path)->asXML();
  1314.         // Aplicar officeId si existe en sesión
  1315.         if ($this->session->has('officeId')) {
  1316.             $xmlBase = str_replace('{officeId}', $this->session->get('officeId'), $xmlBase);
  1317.         }
  1319.         // Reemplazar variables en el body (excepto ProviderId)
  1320.         if (isset($variable)) {
  1321.             foreach ($variable as $key => $value) {
  1322.                 if ($key !== 'ProviderId') {
  1323.                     $body = str_replace('{' . $key . '}', $value, $body);
  1324.                 }
  1325.             }
  1326.         }
  1328.         // Reemplazar transactionId en el body
  1329.         $body = str_replace('{transactionId}', $transactionId, $body);
  1331.         // Reemplazar placeholders en el XML base
  1332.         $replacements = [
  1333.             '{method}' => $method,
  1334.             '{body}' => $body,
  1335.             '{ProviderId}' => $variable['ProviderId'] ?? '',
  1336.         ];
  1338.         return str_replace(array_keys($replacements), array_values($replacements), $xmlBase);
  1339.     }
  1341.     /**
  1342.      * Construye el header XML para peticiones MPX (MPA/MPB).
  1343.      *
  1344.      * @param string $body Cuerpo del XML
  1345.      * @param string $method Método a invocar
  1346.      * @param string $transactionId ID de transacción
  1347.      * @param array $variable Variables para reemplazar
  1348.      * @param int|null $ancillaries Ancillaries flag
  1349.      *
  1350.      * @return string XML completo con header
  1351.      */
  1352.     public function getXmlMpxHeader(string $body, string $method, string $transactionId, array $variable, ?int $ancillaries = null): string
  1353.     {
  1354.         $cacheRefresh = $variable['cacheRefresh'] ?? 'true';
  1355.         $cacheKey = $variable['cacheKey'] ?? '';
  1356.         $path = $this->projectDir . '/app/xmlService/' . mb_strtolower($this->requestType) . 'Request.xml';
  1358.         try {
  1359.             $xml = simplexml_load_file($path);
  1360.             if ($xml === false) {
  1361.                 throw new \Exception("Error cargando XML desde: " . $path);
  1362.             }
  1363.             $xmlBase = $xml->asXML();
  1365.             // Aplicar officeId si existe en sesión
  1366.             if ($this->session->has('officeId')) {
  1367.                 $xmlBase = str_replace('{officeId}', $this->session->get('officeId'), $xmlBase);
  1368.             }
  1369.         } catch (\Exception $e) {
  1370.             throw new \Exception($e->getMessage() . " path: " . $path);
  1371.         }
  1373.         // Reemplazar variables en el body (excepto ProviderId y CoveredTraveler)
  1374.         if (isset($variable)) {
  1375.             foreach ($variable as $key => $value) {
  1376.                 if ($key !== 'ProviderId' && $key !== 'CoveredTraveler') {
  1377.                     $body = str_replace('{' . $key . '}', trim($value), $body);
  1378.                 }
  1379.             }
  1380.         }
  1382.         // Reemplazar transactionId y ancillaries en el body
  1383.         $body = str_replace('{transactionId}', $transactionId, $body);
  1384.         $body = str_replace('{ancillaries}', $ancillaries ?? 0, $body);
  1386.         // Reemplazar placeholders en el XML base
  1387.         $replacements = [
  1388.             '{method}' => $method,
  1389.             '{body}' => $body,
  1390.             '{cacheRefresh}' => $cacheRefresh,
  1391.             '{cacheKey}' => $cacheKey,
  1392.             '{ProviderId}' => $variable['ProviderId'] ?? '',
  1393.         ];
  1395.         $xmlBase = str_replace(array_keys($replacements), array_values($replacements), $xmlBase);
  1397.         // Remover declaración XML si existe
  1398.         return preg_replace('/<\?xml.*?\?>/i', '', $xmlBase);
  1399.     }
  1401.     /**
  1402.      * Construye el XML para consulta de usuario B2C.
  1403.      *
  1404.      * @param string $DocumentType Tipo de documento
  1405.      * @param string $Documentnumber Número de documento
  1406.      *
  1407.      * @return string XML de consulta
  1408.      */
  1409.     public function getXmlUserB2C(string $DocumentType, string $Documentnumber): string
  1410.     {
  1411.         $path = $this->projectDir . '/app/xmlService/mpaUserB2C.xml';
  1413.         //Valores a remplazar
  1414.         $arrayIndex = [
  1415.             '{DocumentType}',
  1416.             '{DocumentNumber}',
  1417.         ];
  1418.         //Nuevos valores
  1419.         $arrayValues = [
  1420.             $DocumentType,
  1421.             $Documentnumber,
  1422.         ];
  1423.         //obtengo el xml base
  1424.         $xmlBase = simplexml_load_file($path)->asXML();
  1426.         $xmlBase = str_replace($arrayIndex, $arrayValues, $xmlBase);
  1428.         return $xmlBase;
  1429.     }
  1431.     /**
  1432.      * Encripta el usuario con una clave secreta.
  1433.      *
  1434.      * @param string $user Usuario a encriptar
  1435.      * @param string $secretKey Clave secreta
  1436.      *
  1437.      * @return string Usuario encriptado
  1438.      */
  1439.     public function encryptUser(string $user, string $secretKey): string
  1440.     {
  1441.         $encryptUser = '';
  1442.         if ('test1' !== $user) {
  1443.             $encryptUser = hash_hmac('sha512', $user, $secretKey . false);
  1444.         } else {
  1445.             $encryptUser = $user;
  1446.         }
  1448.         return $encryptUser;
  1449.     }
  1451.     /**
  1452.      * Configura todas las URLs de los servicios desde un objeto de parámetros.
  1453.      *
  1454.      * @param object $parameters Objeto con las configuraciones de URLs
  1455.      * @return void
  1456.      */
  1457.     public function setUrls($parameters): void
  1458.     {
  1459.         $this->url = $parameters->aviatur_service_web_url;
  1460.         $this->urlMpa = $parameters->aviatur_service_web_url_mpa;
  1461.         $this->urlLoginMpb = $parameters->aviatur_service_web_url_login_mpb;
  1462.         $this->urlAirMpb = $parameters->aviatur_service_web_url_air_mpb;
  1463.         $this->urlHotelMpb = $parameters->aviatur_service_web_url_hotel_mpb;
  1464.         $this->urlCarMpb = $parameters->aviatur_service_web_url_car_mpb;
  1465.         $this->urlTicketMpb = $parameters->aviatur_service_web_url_ticket_mpb;
  1466.         $this->urlCruiseMpb = $parameters->aviatur_service_web_url_cruise_mpb;
  1467.         $this->urlEmission = $parameters->aviatur_service_web_url_emission;
  1468.         $this->requestId = $parameters->aviatur_service_web_request_id;
  1469.         $this->requestType = $parameters->aviatur_service_web_request_type;
  1470.         $this->serviceNameMpa = $parameters->aviatur_service_web_mpa_method;
  1471.         $this->urlPackageMpt = $parameters->aviatur_service_web_mpb_mpt;
  1472.         $this->urlInsuranceMpb = $parameters->aviatur_service_web_url_insurance_mpb;
  1473.         $this->urlBusMpb = $parameters->aviatur_service_web_url_bus_mpb;
  1474.         $this->urlTrainMpb = $parameters->aviatur_service_web_url_train_mpb;
  1475.         $this->urlExperience = $parameters->aviatur_service_web_mpb_experience;
  1476.     }
  1478.     /**
  1479.      * Obtiene o genera un transaction ID.
  1480.      *
  1481.      * @param string $service Servicio a consultar
  1482.      * @param string $provider Proveedor
  1483.      * @param array $variable Variables de configuración
  1484.      *
  1485.      * @return string|array Transaction ID o array con error
  1486.      */
  1487.     public function getTransactionId(string $service, string $provider, array $variable)
  1488.     {
  1489.         if ($this->session->has('transactionId')) {
  1490.             $transactionId = $this->loginService($service, $provider, $variable['ProviderId']);
  1491.             if (isset($transactionId['error'])) {
  1492.                 return $transactionId;
  1493.             } else {
  1494.                 $this->session->set($this->transactionIdSessionName, (string) $transactionId);
  1495.             }
  1496.         } else {
  1497.             $transactionId = $this->session->get('transactionId');
  1498.         }
  1499.         return $transactionId;
  1500.     }
  1502.     /**
  1503.      * getIINRanges()
  1504.      * Para obtener todos los rangos asociados a IIN de las franquicias activas, y estas se manejarán en variables globales con arrays de javascript
  1505.      * Author: Ing. David Rincon
  1506.      * Email: david.rincon@aviatur.com
  1507.      * Date: 2025/03/06
  1508.      * @param $em (Object of DB manager).
  1509.      * @return array
  1510.      */
  1511.     public function getIINRanges($em){
  1512.         $iinRecords = $em->getRepository(\Aviatur\GeneralBundle\Entity\Card::class)->findByActiveFranchises();
  1513.         $ccranges = [];
  1514.         $ccfranchises = [];
  1515.         foreach ($iinRecords as $key => $iinRecord) {
  1516.             $paymentGatewayCode = $iinRecord["paymentgatewaycode"];
  1517.             $description = $iinRecord["description"];
  1518.             $description = strtoupper(str_replace(' ', '', trim($description)));
  1519.             $stringRanges = $iinRecord["ranges"];
  1520.             $ranges = json_decode($stringRanges, true);
  1521.             $stringLengths = $iinRecord["lengths"];
  1522.             $lengths = json_decode($stringLengths, true);
  1523.             $luhn = $iinRecord["luhn"];
  1524.             $cvvDigits = $iinRecord["cvvdigits"];
  1525.             $tempLengths = [];
  1526.             if (!empty($lengths)) {
  1527.                 foreach ($lengths["lengths"] as $length) {
  1528.                     $tempLengths[] = array(0 => $length[0], 1 => (isset($length[1]) ? $length[1] : $length[0]));
  1529.                 }
  1530.             }
  1531.             $tempRecordArrayFranchises = [];
  1532.             $tempRecordArrayFranchises["code"] = $paymentGatewayCode;
  1533.             $tempRecordArrayFranchises["codename"] = $description;
  1534.             $tempRecordArrayFranchises["luhn"] = $luhn;
  1535.             $tempRecordArrayFranchises["length"] = $tempLengths;
  1536.             $tempRecordArrayFranchises["cvvd"] = $cvvDigits;
  1537.             $ccfranchises[$paymentGatewayCode] = $tempRecordArrayFranchises;
  1538.             if (!empty($ranges)) {
  1539.                 foreach ($ranges["ranges"] as $range) {
  1540.                     $tempRecordArrayRanges = [];
  1541.                     $tempRecordArrayRanges["range"][0] = $range[0];
  1542.                     $tempRecordArrayRanges["range"][1] = (isset($range[1]) ? $range[1] : $range[0]);
  1543.                     $tempRecordArrayRanges["minimum"] = strlen($range[0]);
  1544.                     $tempRecordArrayRanges["code"] = $paymentGatewayCode;
  1545.                     $ccranges[] = $tempRecordArrayRanges;
  1546.                 }
  1547.             }
  1548.         }
  1549.         return ["ccranges" => $ccranges, "ccfranchises" => $ccfranchises];
  1550.     }
  1552.     private function encodeJWT($payload, $key, $alg = "HS256") {
  1553.         $header = ['alg' => $alg, 'typ' => 'JWT'];
  1554.         $segments = [];
  1555.         $segments[] = $this->urlsafeB64Encode(\json_encode($header));
  1556.         $segments[] = $this->urlsafeB64Encode(\json_encode($payload));
  1557.         $signing_input = \implode('.', $segments);
  1558.         $signature = \hash_hmac('SHA256', $signing_input, $key, true);
  1559.         $segments[] = $this->urlsafeB64Encode($signature);
  1561.         return \implode('.', $segments);
  1562.     }
  1564.     private function urlsafeB64Encode($input) {
  1565.         return \str_replace('=', '', \strtr(\base64_encode($input), '+/', '-_'));
  1566.     }
  1568.     /**
  1569.      * Decodes a JWT string into a PHP object.
  1570.      *
  1571.      * @param string        $jwt            The JWT
  1572.      * @param string|array  $key            The key, or map of keys.
  1573.      *                                      If the algorithm used is asymmetric, this is the public key
  1574.      * @param array         $allowed_algs   List of supported verification algorithms
  1575.      *                                      Supported algorithms are 'HS256', 'HS384', 'HS512' and 'RS256'
  1576.      *
  1577.      * @return object The JWT's payload as a PHP object
  1578.      *
  1579.      *
  1580.      * @uses jsonDecode
  1581.      * @uses urlsafeB64Decode
  1582.      */
  1583.     public static function decodeJWT($jwt, $key, $allowed_algs = array())
  1584.     {
  1585.         $timestamp = time();
  1587.         if (empty($key)) {
  1588.             throw new WebServiceException('Key may not be empty', '');
  1589.         }
  1590.         if (!is_array($allowed_algs)) {
  1591.             throw new WebServiceException('Algorithm not allowed', '');
  1592.         }
  1593.         $tks = explode('.', $jwt);
  1594.         if (count($tks) != 3) {
  1595.             throw new WebServiceException('Wrong number of segments', '');
  1596.         }
  1597.         list($headb64, $bodyb64, $cryptob64) = $tks;
  1598.         if (null === ($header = static::jsonDecode(static::urlsafeB64Decode($headb64)))) {
  1599.             throw new WebServiceException('Invalid header encoding', '');
  1600.         }
  1601.         if (null === $payload = static::jsonDecode(static::urlsafeB64Decode($bodyb64))) {
  1602.             throw new WebServiceException('Invalid claims encoding', '');
  1603.         }
  1604.         $sig = static::urlsafeB64Decode($cryptob64);
  1606.         if (empty($header->alg)) {
  1607.             throw new WebServiceException('Empty algorithm', '');
  1608.         }
  1609.         if (!in_array($header->alg, $allowed_algs)) {
  1610.             throw new WebServiceException('Algorithm not allowed', '');
  1611.         }
  1612.         if (is_array($key) || $key instanceof \ArrayAccess) {
  1613.             if (isset($header->kid)) {
  1614.                 $key = $key[$header->kid];
  1615.             } else {
  1616.                 throw new WebServiceException('"kid" empty, unable to lookup correct key', '');
  1617.             }
  1618.         }
  1620.         // Check if the nbf if it is defined. This is the time that the
  1621.         // token can actually be used. If it's not yet that time, abort.
  1622.         if (isset($payload->nbf) && $payload->nbf > $timestamp) {
  1623.             throw new WebServiceException(
  1624.                 'Cannot handle token prior to ' . date(\DateTime::ISO8601, $payload->nbf), ''
  1625.             );
  1626.         }
  1628.         // Check that this token has been created before 'now'. This prevents
  1629.         // using tokens that have been created for later use (and haven't
  1630.         // correctly used the nbf claim).
  1631.         if (isset($payload->iat) && $payload->iat > $timestamp) {
  1632.             throw new WebServiceException(
  1633.                 'Cannot handle token prior to ' . date(\DateTime::ISO8601, $payload->iat), ''
  1634.             );
  1635.         }
  1637.         // Check if this token has expired.
  1638.         if (isset($payload->exp) && $timestamp >= $payload->exp) {
  1639.             throw new WebServiceException('Expired token', '');
  1640.         }
  1642.         return $payload;
  1643.     }
  1645.     private static function urlsafeB64Decode(string $input): string {
  1646.         $remainder = \strlen($input) % 4;
  1647.         if ($remainder) {
  1648.             $padlen = 4 - $remainder;
  1649.             $input .= \str_repeat('=', $padlen);
  1650.         }
  1651.         $return = \strtr($input, '-_', '+/');
  1653.         return \base64_decode($return);
  1654.     }
  1656.     public static function jsonDecode(string $input) {
  1657.         $obj = \json_decode($input, false, 512, JSON_BIGINT_AS_STRING);
  1659.         if ($errno = \json_last_error()) {
  1660.             throw new \Exception($errno);
  1661.         } elseif ($obj === null && $input !== 'null') {
  1662.             throw new \Exception('Null result with non-null input');
  1663.         }
  1664.         return $obj;
  1665.     }
  1666. }