NXS_tmhUtilities

TmhUtilities.

Defined (1)

The class is defined in the following location(s).

/inc-cl/apis/tmhUtilities.php  
  1. class NXS_tmhUtilities { 
  2.   /** 
  3.    * Entifies the tweet using the given entities element 
  4.    * 
  5.    * @param array $tweet the json converted to normalised array 
  6.    * @return the tweet text with entities replaced with hyperlinks 
  7.    */ 
  8.   function entify($tweet, &$replacements=array()) { 
  9.     $encoding = mb_internal_encoding(); 
  10.     mb_internal_encoding("UTF-8"); 
  11.  
  12.     $keys = array(); 
  13.     // $replacements = array(); 
  14.     $is_retweet = false; 
  15.  
  16.     if (isset($tweet['retweeted_status'])) { 
  17.       $tweet = $tweet['retweeted_status']; 
  18.       $is_retweet = true; 
  19.     } 
  20.  
  21.     if (!isset($tweet['entities'])) { 
  22.       return $tweet['text']; 
  23.     } 
  24.  
  25.     // prepare the entities 
  26.     foreach ($tweet['entities'] as $type => $things) { 
  27.       foreach ($things as $entity => $value) { 
  28.         $tweet_link = "<a href=\"http://twitter.com/{$tweet['user']['screen_name']}/statuses/{$tweet['id']}\">{$tweet['created_at']}</a>"; 
  29.  
  30.         switch ($type) { 
  31.           case 'hashtags': 
  32.             $href = "<a href=\"http://twitter.com/search?q=%23{$value['text']}\">#{$value['text']}</a>"; 
  33.             break; 
  34.           case 'user_mentions': 
  35.             $href = "@<a href=\"http://twitter.com/{$value['screen_name']}\" title=\"{$value['name']}\">{$value['screen_name']}</a>"; 
  36.             break; 
  37.           case 'urls': 
  38.           case 'media': 
  39.             $url = empty($value['expanded_url']) ? $value['url'] : $value['expanded_url']; 
  40.             $display = isset($value['display_url']) ? $value['display_url'] : str_replace('http://', '', $url); 
  41.             // Not all pages are served in UTF-8 so you may need to do this ... 
  42.             $display = urldecode(str_replace('%E2%80%A6', '…', urlencode($display))); 
  43.             $href = "<a href=\"{$value['url']}\">{$display}</a>"; 
  44.             break; 
  45.         } 
  46.         $keys[$value['indices']['0']] = mb_substr( 
  47.           $tweet['text'],  
  48.           $value['indices']['0'],  
  49.           $value['indices']['1'] - $value['indices']['0'] 
  50.  ); 
  51.         $replacements[$value['indices']['0']] = $href; 
  52.       } 
  53.     } 
  54.  
  55.     ksort($replacements); 
  56.     $replacements = array_reverse($replacements, true); 
  57.     $entified_tweet = $tweet['text']; 
  58.     foreach ($replacements as $k => $v) { 
  59.       // $entified_tweet = substr_replace($entified_tweet, $v, $k, strlen($keys[$k])); 
  60.       $entified_tweet = mb_substr($entified_tweet, 0, $k).$v.mb_substr($entified_tweet, $k + strlen($keys[$k])); 
  61.     } 
  62.     $replacements = array( 
  63.       'replacements' => $replacements,  
  64.       'keys' => $keys 
  65.  ); 
  66.  
  67.     mb_internal_encoding($encoding); 
  68.     return $entified_tweet; 
  69.   } 
  70.  
  71.   /** 
  72.    * Returns the current URL. This is instead of PHP_SELF which is unsafe 
  73.    * 
  74.    * @param bool $dropqs whether to drop the querystring or not. Default true 
  75.    * @return string the current URL 
  76.    */ 
  77.   function php_self($dropqs=true) { 
  78.     $url = sprintf('%s://%s%s',  
  79.       empty($_SERVER['HTTPS']) ? (@$_SERVER['SERVER_PORT'] == '443' ? 'https' : 'http') : 'http',  
  80.       $_SERVER['SERVER_NAME'],  
  81.       $_SERVER['REQUEST_URI'] 
  82.  ); 
  83.  
  84.     $parts = parse_url($url); 
  85.  
  86.     $port = $_SERVER['SERVER_PORT']; 
  87.     $scheme = $parts['scheme']; 
  88.     $host = $parts['host']; 
  89.     $path = @$parts['path']; 
  90.     $qs = @$parts['query']; 
  91.  
  92.     $port or $port = ($scheme == 'https') ? '443' : '80'; 
  93.  
  94.     if (($scheme == 'https' && $port != '443') 
  95.         || ($scheme == 'http' && $port != '80')) { 
  96.       $host = "$host:$port"; 
  97.     } 
  98.     $url = "$scheme://$host$path"; 
  99.     if ( ! $dropqs) 
  100.       return "{$url}?{$qs}"; 
  101.     else 
  102.       return $url; 
  103.   } 
  104.  
  105.   function is_cli() { 
  106.     return (PHP_SAPI == 'cli' && empty($_SERVER['REMOTE_ADDR'])); 
  107.   } 
  108.  
  109.   /** 
  110.    * Debug function for printing the content of an object 
  111.    * 
  112.    * @param mixes $obj 
  113.    */ 
  114.   function pr($obj) { 
  115.  
  116.     if (!self::is_cli()) 
  117.       echo '<pre style="word-wrap: break-word">'; 
  118.     if ( is_object($obj) ) 
  119.       print_r($obj); 
  120.     elseif ( is_array($obj) ) 
  121.       print_r($obj); 
  122.     else 
  123.       echo $obj; 
  124.     if (!self::is_cli()) 
  125.       echo '</pre>'; 
  126.   } 
  127.  
  128.   /** 
  129.    * Make an HTTP request using this library. This method is different to 'request' 
  130.    * because on a 401 error it will retry the request. 
  131.    * 
  132.    * When a 401 error is returned it is possible the timestamp of the client is 
  133.    * too different to that of the API server. In this situation it is recommended 
  134.    * the request is retried with the OAuth timestamp set to the same as the API 
  135.    * server. This method will automatically try that technique. 
  136.    * 
  137.    * This method doesn't return anything. Instead the response should be 
  138.    * inspected directly. 
  139.    * 
  140.    * @param string $method the HTTP method being used. e.g. POST, GET, HEAD etc 
  141.    * @param string $url the request URL without query string parameters 
  142.    * @param array $params the request parameters as an array of key=value pairs 
  143.    * @param string $useauth whether to use authentication when making the request. Default true. 
  144.    * @param string $multipart whether this request contains multipart data. Default false 
  145.    */ 
  146.   function auto_fix_time_request($tmhOAuth, $method, $url, $params=array(), $useauth=true, $multipart=false) { 
  147.     $tmhOAuth->request($method, $url, $params, $useauth, $multipart); 
  148.  
  149.     // if we're not doing auth the timestamp isn't important 
  150.     if ( ! $useauth) 
  151.       return; 
  152.  
  153.     // some error that isn't a 401 
  154.     if ($tmhOAuth->response['code'] != 401) 
  155.       return; 
  156.  
  157.     // some error that is a 401 but isn't because the OAuth token and signature are incorrect 
  158.     // TODO: this check is horrid but helps avoid requesting twice when the username and password are wrong 
  159.     if (stripos($tmhOAuth->response['response'], 'password') !== false) 
  160.      return; 
  161.  
  162.     // force the timestamp to be the same as the Twitter servers, and re-request 
  163.     $tmhOAuth->auto_fixed_time = true; 
  164.     $tmhOAuth->config['force_timestamp'] = true; 
  165.     $tmhOAuth->config['timestamp'] = strtotime($tmhOAuth->response['headers']['date']); 
  166.     return $tmhOAuth->request($method, $url, $params, $useauth, $multipart); 
  167.   } 
  168.  
  169.   /** 
  170.    * Asks the user for input and returns the line they enter 
  171.    * 
  172.    * @param string $prompt the text to display to the user 
  173.    * @return the text entered by the user 
  174.    */ 
  175.   function read_input($prompt) { 
  176.     echo $prompt; 
  177.     $handle = fopen("php://stdin", "r"); 
  178.     $data = fgets($handle); 
  179.     return trim($data); 
  180.   } 
  181.  
  182.   /** 
  183.    * Get a password from the shell. 
  184.    * 
  185.    * This function works on *nix systems only and requires shell_exec and stty. 
  186.    * 
  187.    * @param  boolean $stars Wether or not to output stars for given characters 
  188.    * @return string 
  189.    * @url http://www.dasprids.de/blog/2008/08/22/getting-a-password-hidden-from-stdin-with-php-cli 
  190.    */ 
  191.   function read_password($prompt, $stars=false) { 
  192.     echo $prompt; 
  193.     $style = shell_exec('stty -g'); 
  194.  
  195.     if ($stars === false) { 
  196.       shell_exec('stty -echo'); 
  197.       $password = rtrim(fgets(STDIN), "\n"); 
  198.     } else { 
  199.       shell_exec('stty -icanon -echo min 1 time 0'); 
  200.       $password = ''; 
  201.       while (true) : 
  202.         $char = fgetc(STDIN); 
  203.         if ($char === "\n") : 
  204.           break; 
  205.         elseif (ord($char) === 127) : 
  206.           if (strlen($password) > 0) { 
  207.             fwrite(STDOUT, "\x08 \x08"); 
  208.             $password = substr($password, 0, -1); 
  209.           } 
  210.         else 
  211.           fwrite(STDOUT, "*"); 
  212.           $password .= $char; 
  213.         endif; 
  214.       endwhile; 
  215.     } 
  216.  
  217.     // Reset 
  218.     shell_exec('stty ' . $style); 
  219.     echo PHP_EOL; 
  220.     return $password; 
  221.   } 
  222.  
  223.   /** 
  224.    * Check if one string ends with another 
  225.    * 
  226.    * @param string $haystack the string to check inside of 
  227.    * @param string $needle the string to check $haystack ends with 
  228.    * @return true if $haystack ends with $needle, false otherwise 
  229.    */ 
  230.   function endswith($haystack, $needle) { 
  231.     $haylen = strlen($haystack); 
  232.     $needlelen = strlen($needle); 
  233.     if ($needlelen > $haylen) 
  234.       return false; 
  235.  
  236.     return substr_compare($haystack, $needle, -$needlelen) === 0; 
  237.   } 
  238. }