src/Services/GeneralService.php line 307

Open in your IDE?
  1. <?php
  3. namespace EADPlataforma\Services;
  5. use Psr\Container\ContainerInterface;
  6. use Symfony\Component\HttpFoundation\RequestStack;
  7. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  8. use EADPlataforma\Entity\Session;
  9. use EADPlataforma\Enum\ServicesEnum;
  11. /**
  12.  * GeneralService
  13.  */
  14. class GeneralService
  15. {   
  16.     /**
  17.      * @var ContainerInterface
  18.      */
  19.     protected $container;
  21.     /**
  22.      * @var RequestStack
  23.      */
  24.     protected $requestStack;
  26.     /**
  27.      * @var UrlGeneratorInterface
  28.      */
  29.     protected $router;
  31.     /**
  32.      * @var Array
  33.      */
  34.     protected $eadToken;
  36.     /**
  37.      * @var Object
  38.      */
  39.     protected $dataTokens;
  41.     /**
  42.      * @var Array
  43.      */
  44.     protected $services = [];
  46.     /**
  47.      * Constructor
  48.      *
  49.      * @param ContainerInterface $container
  50.      */
  51.     public function __construct(
  52.         ContainerInterface $container, 
  53.         RequestStack $requestStack, 
  54.         UrlGeneratorInterface $router
  55.     )
  56.     {
  57.         $this->container = $container;
  58.         $this->requestStack = $requestStack;
  59.         $this->router = $router;
  61.         $this->eadToken = $this->container->getParameter('ead-token');
  62.         $this->dataTokens = json_decode($this->container->getParameter('ead-services'));
  63.     }
  65.     public function isSandbox()
  66.     {
  67.         return ($this->eadToken['sandbox'] == ServicesEnum::YES);
  68.     }
  70.     public function isDev()
  71.     {
  72.         return $this->container->getParameter('kernel.environment') == "dev";
  73.     }
  75.     public function getTokenCron()
  76.     {
  77.         return $this->container->getParameter('ead-cron');
  78.     }
  80.     public function getServiceAccess(int $serviceType, ?int $sandbox = ServicesEnum::NO)
  81.     {
  82.         $keyService = "{$serviceType}{$sandbox}";
  83.         if(!empty($this->services[$keyService])){
  84.             return $this->services[$keyService];
  85.         }
  87.         if($this->isSandbox()){
  88.             $sandbox = ServicesEnum::YES;
  89.         }
  91.         $mainServices = [
  92.             ServicesEnum::IP_API,
  93.             ServicesEnum::RDSTATION,
  94.             ServicesEnum::LOGIN,
  95.             ServicesEnum::BLING,
  96.         ];
  98.         if($serviceType == ServicesEnum::AWS_SECRET){
  99.             $this->services[$keyService] = json_decode(
  100.                 $this->container->getParameter('ead-sget')
  101.             );
  103.             return $this->services[$keyService];
  104.         }
  106.         if($sandbox != ServicesEnum::YES || $serviceType == ServicesEnum::MEET){
  107.             if($serviceType == ServicesEnum::AWS_DYNAMODB_GET){
  108.                 $this->services[$keyService] = json_decode(
  109.                     $this->container->getParameter('ead-dget')
  110.                 );
  112.                 return $this->services[$keyService];
  113.             }
  115.             if(!in_array($serviceType, $mainServices)){
  116.                 $serviceSecretId = ServicesEnum::SERVICES_NAME[$serviceType];
  117.                 $serviceSecretId = "{$serviceSecretId}/production";
  119.                 $awsSecretsManager = $this->getService("Aws\\AwsSecretsManager");
  120.                 $info = $awsSecretsManager->getServiceInfo($serviceSecretId);
  122.                 if(!empty($info)){
  123.                     $this->services[$keyService] = $info;
  125.                     return $this->services[$keyService];
  126.                 }
  127.             }
  128.         }
  130.         if(!empty($this->dataTokens)){
  131.             if(isset($this->dataTokens->{$serviceType})){
  132.                 return $this->dataTokens->{$serviceType};
  133.             }
  134.         }
  136.         throw new \Exception("Token not found for service: {$serviceType}");
  138.         return;
  139.     }
  141.     public function getUserFromEADAdmin(
  142.         string $email,
  143.         string $password,
  144.         string $clientId,
  145.         string $ip,
  146.         string $userAgent,
  147.         string $host,
  148.         ?bool $json = false
  149.     )
  150.     {
  152.         $info = $this->getServiceAccess(ServicesEnum::LOGIN);
  154.         $data = [
  155.             "action" => "user",
  156.             "email" => $email,
  157.             "password" => $password,
  158.             "cliente_id" => $clientId,
  159.             "userAgent" => $userAgent,
  160.             "host" => $host,
  161.             "ip" => $ip,
  162.         ];
  164.         $data = http_build_query($data);
  166.         $url = "https://eadmin.eadplataforma.com/modulos/api/?{$data}";
  168.         $ch = curl_init();
  169.         curl_setopt($ch, CURLOPT_URL, $url);
  170.         curl_setopt($ch, CURLOPT_POST, 0);
  171.         curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  172.         curl_setopt($ch, CURLOPT_HTTPHEADER, [
  173.             'Authorization: Token token="' . $info->token . '"'
  174.         ]);
  176.         $response = curl_exec($ch);
  178.         curl_close($ch);
  179.         
  180.         if (!$json){
  181.             $response = json_decode($response, true);
  183.             if($this->isDev()){
  184.                 $discordService = $this->getService('DiscordService');
  185.                 $discordService->setChannel('debug-login');
  187.                 
  188.                 $discordService->setMessage(json_encode($data));
  189.                 $discordService->sendDiscord();
  191.                 if(isset($response['usuario_id'])){
  192.                     $discordService->setMessage($response['usuario_id']);
  193.                     $discordService->sendDiscord();
  194.                 }else if(isset($response['message'])){
  195.                     $discordService->setMessage($response['message']);
  196.                     $discordService->sendDiscord();
  197.                 }
  198.             }
  199.         }
  200.         
  201.         return $response;
  202.     }
  204.     public function getUserFromEADAdminByID(
  205.         string $userId,
  206.         string $clientId,
  207.         string $ip,
  208.         string $userAgent,
  209.         string $host,
  210.         ?bool $json = false
  211.     )
  212.     {
  214.         $info = $this->getServiceAccess(ServicesEnum::LOGIN);
  216.         $data = [
  217.             "action" => "userById",
  218.             "userId" => $userId,
  219.             "cliente_id" => $clientId,
  220.             "userAgent" => $userAgent,
  221.             "host" => $host,
  222.             "ip" => $ip,
  223.         ];
  225.         $data = http_build_query($data);
  227.         $url = "https://eadmin.eadplataforma.com/modulos/api/?{$data}";
  229.         $ch = curl_init();
  230.         curl_setopt($ch, CURLOPT_URL, $url);
  231.         curl_setopt($ch, CURLOPT_POST, 0);
  232.         curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  233.         curl_setopt($ch, CURLOPT_HTTPHEADER, [
  234.             'Authorization: Token token="' . $info->token . '"'
  235.         ]);
  237.         $response = curl_exec($ch);
  239.         curl_close($ch);
  240.         
  241.         if (!$json){
  242.             $response = json_decode($response, true);
  244.             if($this->isDev()){
  245.                 $discordService = $this->getService('DiscordService');
  246.                 $discordService->setChannel('debug-login');
  248.                 
  249.                 $discordService->setMessage(json_encode($data));
  250.                 $discordService->sendDiscord();
  252.                 if(isset($response['usuario_id'])){
  253.                     $discordService->setMessage($response['usuario_id']);
  254.                     $discordService->sendDiscord();
  255.                 }else if(isset($response['message'])){
  256.                     $discordService->setMessage($response['message']);
  257.                     $discordService->sendDiscord();
  258.                 }
  259.             }
  260.         }
  261.         
  262.         return $response;
  263.     }
  265.     public function getContainer()
  266.     {
  267.         return $this->container;
  268.     }
  270.     public function getRequest()
  271.     {
  272.         return $this->requestStack->getCurrentRequest();
  273.     }
  275.     public function getClientIp()
  276.     {
  277.         $request = $this->getRequest();
  278.         if($request){
  279.             return $request->getClientIp();
  280.         }
  282.         return;
  283.     }
  285.     public function getRouter()
  286.     {
  287.         return $this->router;
  288.     }
  290.     public function getPath()
  291.     {
  292.         return $this->container->getParameter('kernel.project_dir');
  293.     }
  295.     public function getPublicPath()
  296.     {
  297.         return "{$this->getPath()}/public/";
  298.     }
  300.     public function getAssetsPath()
  301.     {
  302.         return "{$this->getPath()}/assets/";
  303.     }
  305.     public function getService(string $serviceName)
  306.     {
  307.         $service = $this->container->get("EADPlataforma\Services\\{$serviceName}");
  308.         return $service;
  309.     }
  311.     public function getUtil(string $utilName)
  312.     {
  313.         $util = $this->container->get("EADPlataforma\Util\\{$utilName}");
  314.         return $util;
  315.     }
  317.     public function getSignatureHash(string $value)
  318.     {
  319.         return hash_hmac('sha256', $value, $this->getTokenCron());
  320.     }
  322.     public function signData(string $value)
  323.     {
  324.         $signature = $this->getSignatureHash($value);
  326.         return "{$value}.ead.{$signature}";
  327.     }
  329.     public function signDataWithExpiration(string $value, int $expirationTime = 30)
  330.     {
  331.         $expires = time() + $expirationTime;
  333.         $signature = $this->getSignatureHash("{$value}.ead.{$expires}");
  335.         return "{$value}.ead.{$expires}.ead.{$signature}";
  336.     }
  338.     public function verifySignedDataExpire(string $hash)
  339.     {
  340.         try{
  341.             list($value, $expires, $signature) = explode('.ead.', $hash, 3);
  343.             if(time() >= $expires){
  344.                 return false; 
  345.             }
  347.             $valid = hash_equals($this->getSignatureHash("{$value}.ead.{$expires}"), $signature);
  349.             return $valid ? $value : false;
  350.         }catch(\Exception $e){
  352.         }
  354.         return false;
  355.     }
  357.     public function verifySignedData(string $hash)
  358.     {
  359.         try{
  360.             list($value, $signature) = explode('.ead.', $hash, 2);
  362.             return hash_equals($this->getSignatureHash($value), $signature) ? $value : false;
  363.         }catch(\Exception $e){
  365.         }
  367.         return false;
  368.     }
  370.     public function setCookieSign(string $cookieName, string $value, ?int $time = null)
  371.     {
  372.         $cookieValue = $this->signData($value);
  373.         $cookieName = "edp_{$cookieName}";
  375.         $request = $this->requestStack->getCurrentRequest();
  376.         $host = $request->headers->get('host');
  378.         $options = [
  379.             "expires" => $time,
  380.             "path" => "/",
  381.             "domain" => $host,
  382.             "secure" => true,
  383.             "httponly" => true,
  384.             "samesite" => "Lax",
  385.         ];
  387.         if(in_array($host, ServicesEnum::DOMAIN_DEV)){
  388.             setcookie($cookieName, $cookieValue, $time, '/', $host);
  389.             
  390.             return;
  391.         }
  393.         setcookie(
  394.             $cookieName,
  395.             $cookieValue,
  396.             $options
  397.         );
  399.         return;
  400.     }
  402.     function verifySignedCookie(string $cookieName): bool
  403.     {
  405.         $cookieName = "edp_{$cookieName}";
  407.         $request = $this->requestStack->getCurrentRequest();
  409.         $cookies = $request->cookies;
  410.         if(!$cookies->has($cookieName)){
  411.             return false;
  412.         }
  414.         return $this->verifySignedData($cookies->get($cookieName));
  415.     }
  417.     public function setCookie($cookieName, $value, $time = null, ?bool $useMd5 = true)
  418.     {
  419.         if($useMd5){
  420.             $cookieName = md5($cookieName);
  421.         }
  423.         $cookieName = "edp_{$cookieName}";
  425.         $request = $this->requestStack->getCurrentRequest();
  426.         $host = $request->headers->get('host');
  428.         if(empty($time)){
  429.             $time = time() + (10 * 365 * 24 * 60 * 60);
  430.         }
  432.         $options = [
  433.             "expires" => $time,
  434.             "path" => "/",
  435.             "domain" => $host,
  436.             "secure" => true,
  437.             "httponly" => true,
  438.             "samesite" => "Lax",
  439.         ];
  441.         if(in_array($host, ServicesEnum::DOMAIN_DEV)){
  442.             setcookie($cookieName, $value, $time, '/', $host);
  444.             return;
  445.         }
  447.         setcookie($cookieName, $value, $options);
  449.         return;
  450.     }
  452.     public function getCookie($cookieName, ?bool $useMd5 = true)
  453.     {
  454.         if($useMd5){
  455.             $cookieName = md5($cookieName);
  456.         }
  458.         $cookieName = "edp_{$cookieName}";
  460.         $request = $this->requestStack->getCurrentRequest();
  462.         $cookies = $request->cookies;
  463.         if($cookies->has($cookieName)){
  464.             return $cookies->get($cookieName);
  465.         }
  467.         return;
  468.     }
  470.     public function deleteCookie($cookieName, ?bool $useMd5 = true)
  471.     {
  472.         if($useMd5){
  473.             $cookieName = md5($cookieName);
  474.         }
  476.         $cookieName = "edp_{$cookieName}";
  477.         
  478.         $request = $this->requestStack->getCurrentRequest();
  479.         $host = $request->headers->get('host');
  480.         
  481.         setcookie($cookieName, null, -1, '/', $host); 
  482.     }
  484.     public function getCookieHashIdentify()
  485.     {
  486.         $cookieName = 'hashcartoff';
  487.         $hashIdentify = $this->getCookie($cookieName);
  489.         if(empty($hashIdentify)){
  490.             $hashIdentify = md5(rand() . strtotime(date('Y-m-d H:i:s')));
  491.             $hashIdentify .= md5(rand() . password_hash($hashIdentify, PASSWORD_DEFAULT));
  493.             $this->setCookie($cookieName, $hashIdentify);
  494.         }
  496.         return $hashIdentify;
  497.     }
  499.     public function generateUrl(string $routeName, ?array $params = [])
  500.     {
  501.         return $this->router->generate($routeName, (!empty($params) ? $params : []));
  502.     }
  504.     public function logoffWS(Session $session, string $clientId)
  505.     {
  506.         $url = "https://metrics.eadplataforma.app/api/users/token/invalidate";
  508.         $curl = curl_init();
  509.         curl_setopt($curl, CURLOPT_URL, $url);
  510.         curl_setopt($curl, CURLOPT_TIMEOUT, 50);
  511.             
  512.         $headers = [
  513.             "Content-Type: application/json",
  514.             "Authorization: {$this->getTokenCron()}",
  515.         ];
  517.         $userToken = md5($clientId) . md5($session->getId() . $session->getToken());
  519.         $data = [
  520.             "token" => $userToken,
  521.         ];
  523.         curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
  524.         curl_setopt($curl, CURLOPT_CUSTOMREQUEST, "POST");
  525.         curl_setopt($curl, CURLOPT_POSTFIELDS, json_encode($data));
  526.         curl_setopt($curl, CURLOPT_FOLLOWLOCATION, true);
  527.         curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
  528.         curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, false);
  529.         
  530.         $response = curl_exec($curl);
  531.         $error = curl_error($curl);
  532.         curl_close($curl);
  534.         return;
  535.     }
  536. }