vendor/pierre-granger/apidae-core/src/ApidaeCore.php line 51

  1. <?php
  3. namespace PierreGranger;
  5. use PierreGranger\ApidaeTimer;
  6. use PierreGranger\ApidaeException;
  8. /**
  9.  *
  10.  * @author  Pierre Granger <pierre.granger@apidae-tourisme.com>
  11.  *
  12.  */
  14. class ApidaeCore
  15. {
  16.     private static $url_api = [
  17.         'prod' => 'https://api.apidae-tourisme.com/',
  18.         'dev' => 'https://api.apidae-tourisme.dev/',
  19.         'cooking' => 'https://api.apidae-tourisme.cooking/'
  20.     ];
  22.     private static $url_base = [
  23.         'prod' => 'https://base.apidae-tourisme.com/',
  24.         'dev' => 'https://base.apidae-tourisme.dev/',
  25.         'cooking' => 'https://base.apidae-tourisme.cooking/'
  26.     ];
  28.     /**
  29.      *
  30.      * @var string prod|dev|cooking
  31.      */
  32.     private $env = 'prod';
  34.     protected $timeout = 15; // secondes
  36.     protected $debug;
  37.     protected $timer;
  39.     public static $idApidae = [1, 1157]; // Identifiants des membres Auvergne - Rhône-Alpes Tourisme et Apidae Tourisme
  41.     protected $_config;
  43.     private $token_cache;
  45.     protected $lastPostfields;
  46.     protected $lastResult;
  48.     protected $custom_url_api = null;
  49.     protected $custom_url_base = null;
  51.     public function __construct(array $params = null)
  52.     {
  53.         if (isset($params['debug'])) {
  54.             $this->debug = $params['debug'] ? true : false;
  55.         }
  56.         if (isset($params['type_prod']) && !isset($params['env'])) {
  57.             $params['env'] = $params['type_prod'];
  58.         }
  60.         if (isset($params['env'])) {
  61.             if (in_array($params['env'], array_keys(self::$url_api))) {
  62.                 $this->env = $params['env'];
  63.             } else {
  64.                 throw new ApidaeException('', ApidaeException::NO_PROD);
  65.             }
  66.         }
  68.         if (isset($params['url_api'])) {
  69.             $this->custom_url_api = $params['url_api'];
  70.         }
  71.         if (isset($params['url_base'])) {
  72.             $this->custom_url_base = $params['url_base'];
  73.         }
  75.         if (in_array($this->env, ['preprod', 'dev'])) {
  76.             $this->timeout = 30;
  77.         }
  79.         $this->_config = $params;
  81.         if (isset($params['timer'])) {
  82.             $this->timer = $params['timer'] ? true : false;
  83.         }
  84.         if ($this->timer) {
  85.             $this->timer = new ApidaeTimer(true);
  86.         }
  88.         $this->token_store = [];
  89.     }
  91.     public function url_base()
  92.     {
  93.         if ($this->custom_url_base != null) {
  94.             return $this->custom_url_base;
  95.         }
  96.         return self::$url_base[$this->env];
  97.     }
  99.     public function url_api()
  100.     {
  101.         if ($this->custom_url_api != null) {
  102.             return $this->custom_url_api;
  103.         }
  104.         return self::$url_api[$this->env];
  105.     }
  107.     public function setTimeout(int $timeout)
  108.     {
  109.         if ((int)$timeout > 5 && (int)$timeout < 300) {
  110.             $this->timeout = (int)$timeout;
  111.         }
  112.     }
  114.     public function gimme_token($clientId = null, $secret = null, $debugToken = false)
  115.     {
  116.         $this->start(__METHOD__);
  118.         $clientId = ($clientId != null) ? $clientId : (isset($this->projet_ecriture_clientId) ? $this->projet_ecriture_clientId : null);
  119.         $secret = ($secret != null) ? $secret : (isset($this->projet_ecriture_secret) ? $this->projet_ecriture_secret : null);
  121.         if ($clientId == null || $secret == null) {
  122.             $this->stop(__METHOD__);
  123.             throw new ApidaeException('no clientId', ApidaeException::MISSING_PARAMETER);
  124.         }
  126.         if (isset($this->token_cache[$clientId])) {
  127.             $this->stop(__METHOD__, 'token on token_cache');
  128.             return $this->token_cache[$clientId];
  129.         }
  131.         $result = $this->request('/oauth/token', [
  132.             'USERPWD' => $clientId . ":" . $secret,
  133.             'POSTFIELDS' => "grant_type=client_credentials",
  134.             'format' => 'json'
  135.         ]);
  137.         if ($result['code'] != 200) {
  138.             $this->stop(__METHOD__);
  139.             throw new ApidaeException('invalid token', ApidaeException::INVALID_TOKEN, [
  140.                 'debug' => $this->debug,
  141.                 'result' => $result
  142.             ]);
  143.         }
  145.         $this->stop(__METHOD__);
  146.         $this->token_cache[$clientId] = $result['access_token'];
  147.         return $result['access_token'];
  148.     }
  150.     public function debug($var, $titre = null)
  151.     {
  152.         if (!$this->debug) {
  153.             return;
  154.         }
  155.         if (php_sapi_name() !== 'cli') {
  156.             echo '<p style="font-size:16px;font-weight:bold ;">[debug] ' . (($titre !== null) ? $titre : '') . ' / ' . gettype($var) . '</p>' . PHP_EOL;
  157.             echo '<pre style="color:white;background:black;font-family:monospace;font-size:8px;width:100%;max-height:500px;overflow:auto;">' . PHP_EOL;
  158.             if (is_object($var) || gettype($var) == 'boolean') {
  159.                 print_r($var);
  160.             } elseif (is_array($var) || $this->isJson($var)) {
  161.                 echo json_encode($var, JSON_PRETTY_PRINT);
  162.             } else {
  163.                 echo $var;
  164.             }
  165.             echo PHP_EOL . '</pre>' . PHP_EOL;
  166.         } else {
  167.             if ($titre) {
  168.                 echo $titre . PHP_EOL;
  169.             }
  170.             if (is_object($var) || gettype($var) == 'boolean') {
  171.                 print_r($var);
  172.             } elseif (is_array($var) || $this->isJson($var)) {
  173.                 echo json_encode($var, JSON_PRETTY_PRINT);
  174.             } else {
  175.                 echo $var;
  176.             }
  177.             echo PHP_EOL;
  178.         }
  179.     }
  181.     // https://stackoverflow.com/questions/6041741/fastest-way-to-check-if-a-string-is-json-in-php
  182.     protected function isJson($string)
  183.     {
  184.         json_decode($string);
  185.         return (json_last_error() == JSON_ERROR_NONE);
  186.     }
  188.     public function alerte($sujet, $msg, $mailto = null, $options = null)
  189.     {
  190.         if (is_array($this->_config['mail_admin'])) {
  191.             foreach ($this->_config['mail_admin'] as $mail_admin) {
  192.                 if (!filter_var($mail_admin, FILTER_VALIDATE_EMAIL)) {
  193.                     throw new \Exception(__LINE__ . ' mail admin incorrect : ' . $mail_admin);
  194.                 }
  195.                 if (!isset($first_mail_admin)) {
  196.                     $first_mail_admin = $mail_admin;
  197.                 }
  198.             }
  199.             $mails_admin = $this->_config['mail_admin'];
  200.         } else {
  201.             if (!filter_var($this->_config['mail_admin'], FILTER_VALIDATE_EMAIL)) {
  202.                 throw new \Exception(__LINE__ . ' mail admin incorrect : ' . $this->_config['mail_admin']);
  203.             }
  204.             $first_mail_admin = $this->_config['mail_admin'];
  205.             $mails_admin = [$this->_config['mail_admin']];
  206.         }
  208.         $from = (isset($this->_config['mail_expediteur']) && filter_var($this->_config['mail_expediteur'], FILTER_VALIDATE_EMAIL)) ? $this->_config['mail_expediteur'] : $first_mail_admin;
  210.         if (is_array($mailto)) {
  211.             foreach ($mailto as $mt) {
  212.                 if (!filter_var($mt, FILTER_VALIDATE_EMAIL)) {
  213.                     throw new \Exception(__LINE__ . ' mail to incorrect' . print_r($mt, true));
  214.                 }
  215.             }
  216.         } elseif ($mailto !== null) {
  217.             if (!filter_var($mailto, FILTER_VALIDATE_EMAIL)) {
  218.                 throw new \Exception(__LINE__ . ' mail to incorrect' . print_r($mailto, true));
  219.             }
  220.             $mailto = [$mailto];
  221.         } else {
  222.             $mailto = $mails_admin;
  223.         }
  225.         $endline = "\n";
  226.         $h1 = strip_tags($sujet);
  227.         $sujet = $h1;
  229.         if (is_array($msg)) {
  230.             $new_msg = null;
  231.             if (isset($msg['message'])) {
  232.                 $new_msg .= $msg['message'];
  233.                 unset($msg['message']);
  234.             }
  235.             unset($msg['x']);
  236.             unset($msg['y']);
  237.             $tble = '<table style="clear:both; background:#FFF ; font-size:11px ; margin-bottom:20px ;" border="1" cellspacing="0" cellpadding="6">';
  238.             foreach ($msg as $key => $value) {
  239.                 $tble .= '<tr>';
  240.                 $tble .= '<th><strong>' . ucfirst($key) . '</strong></th>';
  241.                 $tble .= '<td>';
  242.                 if (!is_array($value)) {
  243.                     $tble .= stripslashes(nl2br($value));
  244.                 } else {
  245.                     $tble .= '<pre>' . json_encode($value, JSON_PRETTY_PRINT) . '</pre>';
  246.                 }
  247.                 $tble .= '</td>';
  248.                 $tble .= '</tr>';
  249.             }
  250.             $tble .= '</table>';
  251.             $new_msg .= $tble;
  252.             $msg = $new_msg;
  253.         }
  255.         $message_html = '<html style="text-align : center; margin : 0; padding:0 ; font-family:Verdana ;font-size:10px ;">' . $endline;
  256.         $message_html .= '<div style="text-align:left ;">' . $endline;
  257.         $message_html .= '<div>' . $msg . '</div>' . $endline;
  258.         $message_html .= '</div>' . $endline;
  259.         $message_html .= '</html>' . $endline;
  261.         $message_texte = strip_tags(nl2br($message_html));
  263.         $mail = new \PHPMailer\PHPMailer\PHPMailer();
  264.         $mail->setFrom($from);
  266.         foreach ($mailto as $t) {
  267.             $mail->addAddress($t);
  268.         }
  270.         foreach ($mails_admin as $mail_admin) {
  271.             $mail->AddBCC($mail_admin);
  272.         }
  274.         $mail->CharSet = 'UTF-8';
  275.         $mail->isHTML(true);
  276.         $mail->Subject = $sujet;
  277.         $mail->Body = $message_html;
  278.         $mail->AltBody = $message_texte;
  279.         return $mail->send();
  280.     }
  282.     public function start($titre, $details = null)
  283.     {
  284.         if ($this->timer) {
  285.             $this->timer->start($titre, $details);
  286.         }
  287.     }
  288.     public function stop($titre, $details = null)
  289.     {
  290.         if ($this->timer) {
  291.             $this->timer->stop($titre, $details);
  292.         }
  293.     }
  294.     public function timer()
  295.     {
  296.         if ($this->timer) {
  297.             $this->timer->timer();
  298.         }
  299.     }
  301.     public function showException($e)
  302.     {
  303.         ApidaeException::showException($e);
  304.     }
  306.     /**
  307.      * Cette fonction a pour but de gérer tous les appels aux API Apidae.
  308.      * Elle ne gère pas les erreurs elle-même, parce que selon les cas les erreurs n'ont pas la même signifiation :
  309.      * un retour 404 sur un objet est acceptable, mais il ne l'est pas sur un "getUserProfile" par exemple (qui suppose que l'utilisateur soit identifié, et donc qu'il existe)
  310.      *
  311.      * @param    string    $path    chemin relatif vers l'API (/api/v002/...)
  312.      * @param    array|null    $params    paramètres
  313.      * @param    string    $params['format']    Si json : déclenchera une exception en cas de retour non json
  314.      * @param    string    $params['POST']
  315.      * @param    string    $params['CUSTOMREQUEST']    PUT
  316.      * @param    string    $params['POSTFIELDS']
  317.      * @param    string    $params['USERPWD']    couple clientId:secret
  318.      * @param    array    $params['header']
  319.      * @param    string    $params['token']    token, récupéré le plus souvent avec gimme_token
  320.      * @param    string    $params['url_type']    api|base (default : api)
  321.      * @see        ApidaeSso::getSsoToken
  322.      * @see        ApidaeSso::refreshSsoToken
  323.      * @see        ApidaeSso::getUserProfile
  324.      * @see        ApidaeSso::getUserPermissionOnObject
  325.      *
  326.      */
  327.     protected function request(string $path, $params = null)
  328.     {
  329.         $this->lastResult = null;
  331.         $expr = '#^(/api/v002)?/[a-zA-Z0-9-_/]+#ui';
  332.         if (!preg_match($expr, $path)) {
  333.             throw new ApidaeException('request : wrong path', ApidaeException::INVALID_PARAMETER, [
  334.                 'debug' => $this->debug,
  335.                 'method' => __METHOD__,
  336.                 'preg_fail' => $expr . ' failed on ' . $path
  337.             ]);
  338.         }
  340.         $header = [];
  341.         if (isset($params['header'])) {
  342.             $header = $params['header'];
  343.         }
  345.         $header[] = 'Accept: application/json';
  346.         if (isset($params['token'])) {
  347.             $header[] = "Authorization: Bearer " . $params['token'];
  348.         }
  350.         if (isset($params['url_type']) && $params['url_type'] == 'base') {
  351.             $url = $this->url_base() . $path;
  352.         } else {
  353.             $url = $this->url_api() . $path;
  354.         }
  356.         // Remplacement des // par /
  357.         $url = preg_replace('#([^:])//#', '$1/', $url);
  359.         $ch = curl_init();
  361.         $curl_opts = [];
  363.         $curl_opts[CURLOPT_URL] = $url;
  365.         if (sizeof($header) > 0) {
  366.             $curl_opts[CURLOPT_HTTPHEADER] = $header;
  367.         }
  369.         if (isset($params['USERPWD'])) {
  370.             $curl_opts[CURLOPT_USERPWD] = $params['USERPWD'];
  371.         }
  373.         if (isset($params['POSTFIELDS'])) {
  374.             $curl_opts[CURLOPT_POSTFIELDS] = $params['POSTFIELDS'];
  375.             $this->lastPostfields = $params['POSTFIELDS'];
  376.         }
  378.         if (isset($params['CUSTOMREQUEST'])) {
  379.             $curl_opts[CURLOPT_CUSTOMREQUEST] = $params['CUSTOMREQUEST'];
  380.         }
  382.         if (isset($params['POST'])) {
  383.             $curl_opts[CURLOPT_POST] = $params['POST'];
  384.         }
  386.         $curl_opts[CURLOPT_HEADER] = true;
  387.         $curl_opts[CURLOPT_SSL_VERIFYPEER] = false;
  389.         /** Le verbose affiche surtout des infos d'identification, en général peu utiles */
  390.         //$curl_opts[CURLOPT_VERBOSE] = $this->debug;
  392.         $curl_opts[CURLOPT_ENCODING] = 'UTF-8';
  393.         $curl_opts[CURLOPT_RETURNTRANSFER] = true;
  394.         $curl_opts[CURLOPT_FOLLOWLOCATION] = true;
  395.         $curl_opts[CURLOPT_CONNECTTIMEOUT] = $this->timeout;
  396.         $curl_opts[CURLOPT_TIMEOUT] = $this->timeout;
  398.         curl_setopt_array($ch, $curl_opts);
  400.         $response = curl_exec($ch);
  402.         if ($response === false) {
  403.             $details = [
  404.                 'curl_error' => curl_error($ch),
  405.                 'curl_opts' => $curl_opts
  406.             ];
  407.             throw new ApidaeException('curl_response false', ApidaeException::NO_RESPONSE, $details);
  408.         }
  410.         $header_size = curl_getinfo($ch, CURLINFO_HEADER_SIZE);
  412.         $return = [
  413.             'code' => curl_getinfo($ch, CURLINFO_HTTP_CODE),
  414.             'header' => substr($response, 0, $header_size),
  415.             'body' => substr($response, $header_size)
  416.         ];
  418.         $body_array = json_decode($return['body'], true);
  420.         if (json_last_error() == JSON_ERROR_NONE) {
  421.             if (is_array($body_array)) {
  422.                 $return = array_merge($return, $body_array);
  423.             }
  424.         } elseif (isset($params['format']) && $params['format'] == 'json') {
  425.             $details = [
  426.                 'debug' => $this->debug,
  427.                 'curl_opts' => $curl_opts,
  428.                 'return' => @$return
  429.             ];
  430.             throw new ApidaeException('response body is not json', ApidaeException::NO_JSON, $details);
  431.         }
  433.         $this->lastResult = $return;
  434.         return $return;
  435.     }
  437.     /**
  438.      * Renvoie le détail de $result de ApidaeCore::request
  439.      * En cas de retour correct, renvoie un tableau :
  440.      * [
  441.      *     'code' => 200,
  442.      *     'header' => 'HTTP/1.1 100 Continue...',
  443.      *     'body' => '{"status":"MODIFICATION_VALIDATION_ASKED"}',
  444.      *     'object' => {
  445.      *         'status' => 'MODIFICATION_VALIDATION_ASKED'
  446.      *     }
  447.      *     'array' => [
  448.      *         'status' => 'MODIFICATION_VALIDATION_ASKED'
  449.      *     ]
  450.      * ]
  451.      *
  452.      * Exemple erreur
  453.      * [
  454.      *     'body' => '{"message":"Cet objet est déjà en cours de modification","errorType":"ECRITURE_FORBIDDEN}',
  455.      *     'object' => {
  456.      *         'message' => 'Cet objet...',
  457.      *         'errorType' => 'ECRITURE_FORBIDDEN,
  458.      *     },
  459.      *     'array' => [
  460.      *         'message' => 'Cet objet...',
  461.      *         'errorType' => 'ECRITURE_FORBIDDEN,
  462.      *     ]
  463.      * ]
  464.      */
  465.     public function lastResult()
  466.     {
  467.         return $this->lastResult;
  468.     }
  470.     public function lastPostfields()
  471.     {
  472.         return $this->lastPostfields;
  473.     }
  474.     public function lastRequest()
  475.     {
  476.         return $this->lastPostfields();
  477.     }
  479.     public function getEnv()
  480.     {
  481.         return $this->env ;
  482.     }
  483. }