src/Services/GeneralService.php line 330

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\HttpFoundation\Session\SessionInterface;
  8. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  9. use EADPlataforma\Entity\Session;
  10. use EADPlataforma\Enum\ServicesEnum;
  12. /**
  13.  * GeneralService
  14.  */
  15. class GeneralService
  16. {   
  17.     /**
  18.      * @var ContainerInterface
  19.      */
  20.     protected $container;
  22.     /**
  23.      * @var RequestStack
  24.      */
  25.     protected $requestStack;
  27.     /**
  28.      * @var UrlGeneratorInterface
  29.      */
  30.     protected $router;
  32.     /**
  33.      * @var Array
  34.      */
  35.     protected $eadToken;
  37.     /**
  38.      * @var Object
  39.      */
  40.     protected $dataTokens;
  42.     /**
  43.      * @var Array
  44.      */
  45.     protected $services = [];
  47.     /**
  48.      * @var SessionInterface
  49.      */
  50.     protected $sessionSym;
  52.     /**
  53.      * Constructor
  54.      *
  55.      * @param ContainerInterface $container
  56.      */
  57.     public function __construct(
  58.         ContainerInterface $container, 
  59.         RequestStack $requestStack, 
  60.         UrlGeneratorInterface $router,
  61.         SessionInterface $sessionSym
  62.     )
  63.     {
  64.         $this->container = $container;
  65.         $this->requestStack = $requestStack;
  66.         $this->router = $router;
  67.         $this->sessionSym = $sessionSym;
  69.         $this->eadToken = $this->container->getParameter('ead-token');
  70.         $this->dataTokens = json_decode($this->container->getParameter('ead-services'));
  71.     }
  73.     public function isSandbox()
  74.     {
  75.         return ($this->eadToken['sandbox'] == ServicesEnum::YES);
  76.     }
  78.     public function isDev()
  79.     {
  80.         return $this->container->getParameter('kernel.environment') == "dev";
  81.     }
  83.     public function getSessionSym()
  84.     {
  85.         return $this->sessionSym;
  86.     }
  88.     public function getTokenCron()
  89.     {
  90.         return $this->container->getParameter('ead-cron');
  91.     }
  93.     public function getServiceAccess(int $serviceType, ?int $sandbox = ServicesEnum::NO)
  94.     {
  95.         $keyService = "{$serviceType}{$sandbox}";
  96.         if(!empty($this->services[$keyService])){
  97.             return $this->services[$keyService];
  98.         }
  100.         if($this->isSandbox()){
  101.             $sandbox = ServicesEnum::YES;
  102.         }
  104.         $mainServices = [
  105.             ServicesEnum::IP_API,
  106.             ServicesEnum::RDSTATION,
  107.             ServicesEnum::LOGIN,
  108.             ServicesEnum::BLING,
  109.         ];
  111.         if($serviceType == ServicesEnum::AWS_SECRET){
  112.             $this->services[$keyService] = json_decode(
  113.                 $this->container->getParameter('ead-sget')
  114.             );
  116.             return $this->services[$keyService];
  117.         }
  119.         if($sandbox != ServicesEnum::YES || $serviceType == ServicesEnum::MEET){
  120.             if($serviceType == ServicesEnum::AWS_DYNAMODB_GET){
  121.                 $this->services[$keyService] = json_decode(
  122.                     $this->container->getParameter('ead-dget')
  123.                 );
  125.                 return $this->services[$keyService];
  126.             }
  128.             if(!in_array($serviceType, $mainServices)){
  129.                 $serviceSecretId = ServicesEnum::SERVICES_NAME[$serviceType];
  130.                 $serviceSecretId = "{$serviceSecretId}/production";
  132.                 $awsSecretsManager = $this->getService("Aws\\AwsSecretsManager");
  133.                 $info = $awsSecretsManager->getServiceInfo($serviceSecretId);
  135.                 if(!empty($info)){
  136.                     $this->services[$keyService] = $info;
  138.                     return $this->services[$keyService];
  139.                 }
  140.             }
  141.         }
  143.         if(!empty($this->dataTokens)){
  144.             if(isset($this->dataTokens->{$serviceType})){
  145.                 return $this->dataTokens->{$serviceType};
  146.             }
  147.         }
  149.         throw new \Exception("Token not found for service: {$serviceType}");
  151.         return;
  152.     }
  154.     public function getUserFromEADAdmin(
  155.         string $email,
  156.         string $password,
  157.         string $clientId,
  158.         string $ip,
  159.         string $userAgent,
  160.         string $host,
  161.         ?bool $json = false
  162.     )
  163.     {
  165.         $info = $this->getServiceAccess(ServicesEnum::LOGIN);
  167.         $data = [
  168.             "action" => "user",
  169.             "email" => $email,
  170.             "password" => $password,
  171.             "cliente_id" => $clientId,
  172.             "userAgent" => $userAgent,
  173.             "host" => $host,
  174.             "ip" => $ip,
  175.         ];
  177.         $data = http_build_query($data);
  179.         $url = "https://eadmin.eadplataforma.com/modulos/api/?{$data}";
  181.         $ch = curl_init();
  182.         curl_setopt($ch, CURLOPT_URL, $url);
  183.         curl_setopt($ch, CURLOPT_POST, 0);
  184.         curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  185.         curl_setopt($ch, CURLOPT_HTTPHEADER, [
  186.             'Authorization: Token token="' . $info->token . '"'
  187.         ]);
  189.         $response = curl_exec($ch);
  191.         curl_close($ch);
  192.         
  193.         if (!$json){
  194.             $response = json_decode($response, true);
  196.             if($this->isDev()){
  197.                 $discordService = $this->getService('DiscordService');
  198.                 $discordService->setChannel('debug-login');
  200.                 
  201.                 $discordService->setMessage(json_encode($data));
  202.                 $discordService->sendDiscord();
  204.                 if(isset($response['usuario_id'])){
  205.                     $discordService->setMessage($response['usuario_id']);
  206.                     $discordService->sendDiscord();
  207.                 }else if(isset($response['message'])){
  208.                     $discordService->setMessage($response['message']);
  209.                     $discordService->sendDiscord();
  210.                 }
  211.             }
  212.         }
  213.         
  214.         return $response;
  215.     }
  217.     public function getUserFromEADAdminByID(
  218.         string $userId,
  219.         string $clientId,
  220.         string $ip,
  221.         string $userAgent,
  222.         string $host,
  223.         ?bool $json = false
  224.     )
  225.     {
  227.         $info = $this->getServiceAccess(ServicesEnum::LOGIN);
  229.         $data = [
  230.             "action" => "userById",
  231.             "userId" => $userId,
  232.             "cliente_id" => $clientId,
  233.             "userAgent" => $userAgent,
  234.             "host" => $host,
  235.             "ip" => $ip,
  236.         ];
  238.         $data = http_build_query($data);
  240.         $url = "https://eadmin.eadplataforma.com/modulos/api/?{$data}";
  242.         $ch = curl_init();
  243.         curl_setopt($ch, CURLOPT_URL, $url);
  244.         curl_setopt($ch, CURLOPT_POST, 0);
  245.         curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  246.         curl_setopt($ch, CURLOPT_HTTPHEADER, [
  247.             'Authorization: Token token="' . $info->token . '"'
  248.         ]);
  250.         $response = curl_exec($ch);
  252.         curl_close($ch);
  253.         
  254.         if (!$json){
  255.             $response = json_decode($response, true);
  257.             if($this->isDev()){
  258.                 $discordService = $this->getService('DiscordService');
  259.                 $discordService->setChannel('debug-login');
  261.                 
  262.                 $discordService->setMessage(json_encode($data));
  263.                 $discordService->sendDiscord();
  265.                 if(isset($response['usuario_id'])){
  266.                     $discordService->setMessage($response['usuario_id']);
  267.                     $discordService->sendDiscord();
  268.                 }else if(isset($response['message'])){
  269.                     $discordService->setMessage($response['message']);
  270.                     $discordService->sendDiscord();
  271.                 }
  272.             }
  273.         }
  274.         
  275.         return $response;
  276.     }
  278.     public function getContainer()
  279.     {
  280.         return $this->container;
  281.     }
  283.     public function getRequest()
  284.     {
  285.         return $this->requestStack->getCurrentRequest();
  286.     }
  288.     public function getClientIp()
  289.     {
  290.         $request = $this->getRequest();
  291.         if($request){
  292.             return $request->getClientIp();
  293.         }
  295.         return;
  296.     }
  298.     public function getHost()
  299.     {
  300.         $request = $this->getRequest();
  301.         if($request){
  302.             return $request->getHost();
  303.         }
  305.         return;
  306.     }
  308.     public function getRouter()
  309.     {
  310.         return $this->router;
  311.     }
  313.     public function getPath()
  314.     {
  315.         return $this->container->getParameter('kernel.project_dir');
  316.     }
  318.     public function getPublicPath()
  319.     {
  320.         return "{$this->getPath()}/public/";
  321.     }
  323.     public function getAssetsPath()
  324.     {
  325.         return "{$this->getPath()}/assets/";
  326.     }
  328.     public function getService(string $serviceName)
  329.     {
  330.         $service = $this->container->get("EADPlataforma\Services\\{$serviceName}");
  331.         return $service;
  332.     }
  334.     public function getUtil(string $utilName)
  335.     {
  336.         $util = $this->container->get("EADPlataforma\Util\\{$utilName}");
  337.         return $util;
  338.     }
  340.     public function getSignatureHash(string $value)
  341.     {
  342.         return hash_hmac('sha256', $value, $this->getTokenCron());
  343.     }
  345.     public function signData(string $value)
  346.     {
  347.         $signature = $this->getSignatureHash($value);
  349.         return "{$value}.ead.{$signature}";
  350.     }
  352.     public function signDataWithExpiration(string $value, int $expirationTime = 30)
  353.     {
  354.         $expires = time() + $expirationTime;
  356.         $signature = $this->getSignatureHash("{$value}.ead.{$expires}");
  358.         return "{$value}.ead.{$expires}.ead.{$signature}";
  359.     }
  361.     public function verifySignedDataExpire(string $hash)
  362.     {
  363.         try{
  364.             list($value, $expires, $signature) = explode('.ead.', $hash, 3);
  366.             if(time() >= $expires){
  367.                 return false; 
  368.             }
  370.             $valid = hash_equals($this->getSignatureHash("{$value}.ead.{$expires}"), $signature);
  372.             return $valid ? $value : false;
  373.         }catch(\Exception $e){
  375.         }
  377.         return false;
  378.     }
  380.     public function verifySignedData(string $hash)
  381.     {
  382.         try{
  383.             list($value, $signature) = explode('.ead.', $hash, 2);
  385.             return hash_equals($this->getSignatureHash($value), $signature) ? $value : false;
  386.         }catch(\Exception $e){
  388.         }
  390.         return false;
  391.     }
  393.     public function setCookieSign(string $cookieName, string $value, ?int $time = null)
  394.     {
  395.         $cookieValue = $this->signData($value);
  396.         $cookieName = "edp_{$cookieName}";
  398.         $request = $this->requestStack->getCurrentRequest();
  399.         $host = $request->headers->get('host');
  401.         $options = [
  402.             "expires" => $time,
  403.             "path" => "/",
  404.             "domain" => $host,
  405.             "secure" => true,
  406.             "httponly" => true,
  407.             "samesite" => "Lax",
  408.         ];
  410.         if(in_array($host, ServicesEnum::DOMAIN_DEV)){
  411.             setcookie($cookieName, $cookieValue, $time, '/', $host);
  412.             
  413.             return;
  414.         }
  416.         setcookie(
  417.             $cookieName,
  418.             $cookieValue,
  419.             $options
  420.         );
  422.         return;
  423.     }
  425.     function verifySignedCookie(string $cookieName): bool
  426.     {
  428.         $cookieName = "edp_{$cookieName}";
  430.         $request = $this->requestStack->getCurrentRequest();
  432.         $cookies = $request->cookies;
  433.         if(!$cookies->has($cookieName)){
  434.             return false;
  435.         }
  437.         return $this->verifySignedData($cookies->get($cookieName));
  438.     }
  440.     public function setCookie($cookieName, $value, $time = null, ?bool $useMd5 = true)
  441.     {
  442.         if($useMd5){
  443.             $cookieName = md5($cookieName);
  444.         }
  446.         $cookieName = "edp_{$cookieName}";
  448.         $request = $this->requestStack->getCurrentRequest();
  449.         $host = $request->headers->get('host');
  451.         if(empty($time)){
  452.             $time = time() + (10 * 365 * 24 * 60 * 60);
  453.         }
  455.         $options = [
  456.             "expires" => $time,
  457.             "path" => "/",
  458.             "domain" => $host,
  459.             "secure" => true,
  460.             "httponly" => true,
  461.             "samesite" => "Lax",
  462.         ];
  464.         if(in_array($host, ServicesEnum::DOMAIN_DEV)){
  465.             setcookie($cookieName, $value, $time, '/', $host);
  467.             return;
  468.         }
  470.         setcookie($cookieName, $value, $options);
  472.         return;
  473.     }
  475.     public function getCookie($cookieName, ?bool $useMd5 = true)
  476.     {
  477.         if($useMd5){
  478.             $cookieName = md5($cookieName);
  479.         }
  481.         $cookieName = "edp_{$cookieName}";
  483.         $request = $this->requestStack->getCurrentRequest();
  485.         $cookies = $request->cookies;
  486.         if($cookies->has($cookieName)){
  487.             return $cookies->get($cookieName);
  488.         }
  490.         return;
  491.     }
  493.     public function deleteCookie($cookieName, ?bool $useMd5 = true)
  494.     {
  495.         if($useMd5){
  496.             $cookieName = md5($cookieName);
  497.         }
  499.         $cookieName = "edp_{$cookieName}";
  500.         
  501.         $request = $this->requestStack->getCurrentRequest();
  502.         $host = $request->headers->get('host');
  503.         
  504.         setcookie($cookieName, null, -1, '/', $host); 
  505.     }
  507.     public function getCookieHashIdentify()
  508.     {
  509.         $cookieName = 'hashcartoff';
  510.         $hashIdentify = $this->getCookie($cookieName);
  512.         if(empty($hashIdentify)){
  513.             $hashIdentify = md5(rand() . strtotime(date('Y-m-d H:i:s')));
  514.             $hashIdentify .= md5(rand() . password_hash($hashIdentify, PASSWORD_DEFAULT));
  516.             $this->setCookie($cookieName, $hashIdentify);
  517.         }
  519.         return $hashIdentify;
  520.     }
  522.     public function generateUrl(string $routeName, ?array $params = [])
  523.     {
  524.         return $this->router->generate($routeName, (!empty($params) ? $params : []));
  525.     }
  527.     public function logoffWS(Session $session, string $clientId)
  528.     {
  529.         $url = "https://metrics.eadplataforma.app/api/users/token/invalidate";
  531.         $curl = curl_init();
  532.         curl_setopt($curl, CURLOPT_URL, $url);
  533.         curl_setopt($curl, CURLOPT_TIMEOUT, 50);
  534.             
  535.         $headers = [
  536.             "Content-Type: application/json",
  537.             "Authorization: {$this->getTokenCron()}",
  538.         ];
  540.         $userToken = md5($clientId) . md5($session->getId() . $session->getToken());
  542.         $data = [
  543.             "token" => $userToken,
  544.         ];
  546.         curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
  547.         curl_setopt($curl, CURLOPT_CUSTOMREQUEST, "POST");
  548.         curl_setopt($curl, CURLOPT_POSTFIELDS, json_encode($data));
  549.         curl_setopt($curl, CURLOPT_FOLLOWLOCATION, true);
  550.         curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
  551.         curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, false);
  552.         
  553.         $response = curl_exec($curl);
  554.         $error = curl_error($curl);
  555.         curl_close($curl);
  557.         return;
  558.     }
  559. }