WPN_Helper

Class WPN_Helper.

Defined (1)

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

/includes/Helper.php  
  1. final class WPN_Helper 
  2. { 
  3.     /** 
  4.      * @param $value 
  5.      * @return array|string 
  6.      */ 
  7.     public static function addslashes( $value ) 
  8.     { 
  9.         $value = is_array($value) ? 
  10.             array_map(array( 'self', 'addslashes' ), $value) : 
  11.             addslashes($value); 
  12.         return $value; 
  13.     } 
  14.  
  15.     /** 
  16.      * @param $input 
  17.      * @return array|string 
  18.      */ 
  19.     public static function utf8_encode( $input ) { 
  20.         if ( is_array( $input ) )    { 
  21.             return array_map( array( 'self', 'utf8_encode' ), $input ); 
  22.         }else{ 
  23.             return utf8_encode( $input ); 
  24.         } 
  25.     } 
  26.  
  27.     /** 
  28.      * @param $input 
  29.      * @return array|string 
  30.      */ 
  31.     public static function utf8_decode( $input ) { 
  32.         if ( is_array( $input ) )    { 
  33.             return array_map( array( 'self', 'utf8_decode' ), $input ); 
  34.         }else{ 
  35.             return utf8_decode( $input ); 
  36.         } 
  37.     } 
  38.  
  39.     /** 
  40.      * @param $search 
  41.      * @param $replace 
  42.      * @param $subject 
  43.      * @return mixed 
  44.      */ 
  45.     public static function str_replace( $search, $replace, $subject ) { 
  46.         if( is_array( $subject ) ) { 
  47.             foreach( $subject as &$oneSubject ) 
  48.                 $oneSubject = WPN_Helper::str_replace($search, $replace, $oneSubject); 
  49.             unset($oneSubject); 
  50.             return $subject; 
  51.         } else { 
  52.             return str_replace($search, $replace, $subject); 
  53.         } 
  54.     } 
  55.  
  56.     /** 
  57.      * @param $value 
  58.      * @param int $flag 
  59.      * @return array|string 
  60.      */ 
  61.     public static function html_entity_decode( $value, $flag = ENT_COMPAT ) { 
  62.         $value = is_array($value) ? 
  63.             array_map( array( 'self', 'html_entity_decode' ), $value) : 
  64.             html_entity_decode( $value, $flag ); 
  65.         return $value; 
  66.     } 
  67.  
  68.     /** 
  69.      * @param $value 
  70.      * @return array|string 
  71.      */ 
  72.     public static function htmlspecialchars( $value ) { 
  73.         $value = is_array($value) ? 
  74.             array_map( array( 'self', 'htmlspecialchars' ), $value) : 
  75.             htmlspecialchars( $value ); 
  76.         return $value; 
  77.     } 
  78.  
  79.     /** 
  80.      * @param $value 
  81.      * @return array|string 
  82.      */ 
  83.     public static function stripslashes( $value ) { 
  84.         $value = is_array($value) ? 
  85.             array_map( array( 'self', 'stripslashes' ), $value) : 
  86.             stripslashes($value); 
  87.         return $value; 
  88.     } 
  89.  
  90.     /** 
  91.      * @param $value 
  92.      * @return array|string 
  93.      */ 
  94.     public static function esc_html( $value ) 
  95.     { 
  96.         $value = is_array($value) ? 
  97.             array_map( array( 'self', 'esc_html' ), $value) : 
  98.             esc_html($value); 
  99.         return $value; 
  100.     } 
  101.  
  102.     /** 
  103.      * @param $value 
  104.      * @return array|string 
  105.      */ 
  106.     public static function kses_post( $value ) 
  107.     { 
  108.         $value = is_array( $value ) ? 
  109.             array_map(  array( 'self', 'kses_post' ), $value ) : 
  110.             wp_kses_post($value); 
  111.         return $value; 
  112.     } 
  113.  
  114.     /** 
  115.      * @param $value 
  116.      * @return array|string 
  117.      */ 
  118.     public static function strip_tags( $value ) 
  119.     { 
  120.         $value = is_array( $value ) ? 
  121.             array_map( array( 'self', 'strip_tags' ), $value ) : 
  122.             strip_tags( $value ); 
  123.         return $value; 
  124.     } 
  125.  
  126.     /** 
  127.      * String to Bytes 
  128.      * 
  129.      * Converts PHP settings from a string to bytes. 
  130.      * 
  131.      * @param $size 
  132.      * @return float 
  133.      */ 
  134.     public static function string_to_bytes( $size ) 
  135.     { 
  136.         // Remove the non-unit characters from the size. 
  137.         $unit = preg_replace('/[^bkmgtpezy]/i', '', $size); 
  138.  
  139.         // Remove the non-numeric characters from the size. 
  140.         $size = preg_replace('/[^0-9\.]/', '', $size); 
  141.  
  142.         if ( $unit && is_array( $unit ) ) { 
  143.             // Find the position of the unit in the ordered string which is the power of magnitude to multiply a kilobyte by. 
  144.             $size *= pow( 1024, stripos( 'bkmgtpezy', $unit[0] ) ); 
  145.         } 
  146.  
  147.         return round($size); 
  148.     } 
  149.  
  150.     public static function str_putcsv( $array, $delimiter = ', ', $enclosure = '"', $terminator = "\n" ) { 
  151.         // First convert associative array to numeric indexed array 
  152.         $workArray = array(); 
  153.         foreach ($array as $key => $value) { 
  154.         $workArray[] = $value; 
  155.         } 
  156.  
  157.         $returnString = '';                 # Initialize return string 
  158.         $arraySize = count( $workArray );     # Get size of array 
  159.  
  160.         for ( $i=0; $i<$arraySize; $i++ ) { 
  161.             // Nested array, process nest item 
  162.             if ( is_array( $workArray[$i] ) ) { 
  163.                 $returnString .= self::str_putcsv( $workArray[$i], $delimiter, $enclosure, $terminator ); 
  164.             } else { 
  165.                 switch ( gettype( $workArray[$i] ) ) { 
  166.                     // Manually set some strings 
  167.                     case "NULL":     $_spFormat = ''; break; 
  168.                     case "boolean":  $_spFormat = ($workArray[$i] == true) ? 'true': 'false'; break; 
  169.                     // Make sure sprintf has a good datatype to work with 
  170.                     case "integer":  $_spFormat = '%i'; break; 
  171.                     case "double":   $_spFormat = '%0.2f'; break; 
  172.                     case "string":   $_spFormat = '%s'; $workArray[$i] = str_replace("$enclosure", "$enclosure$enclosure", $workArray[$i]); break; 
  173.                     // Unknown or invalid items for a csv - note: the datatype of array is already handled above, assuming the data is nested 
  174.                     case "object": 
  175.                     case "resource": 
  176.                     default:         $_spFormat = ''; break; 
  177.                 } 
  178.                 $returnString .= sprintf('%2$s'.$_spFormat.'%2$s', $workArray[$i], $enclosure); 
  179.                 $returnString .= ($i < ($arraySize-1)) ? $delimiter : $terminator; 
  180.             } 
  181.         } 
  182.         // Done the workload, return the output information 
  183.         return $returnString; 
  184.     } 
  185.  
  186.     public static function get_query_string( $key, $default = FALSE ) 
  187.     { 
  188.         if( ! isset( $_GET[ $key ] ) ) return $default; 
  189.  
  190.         $value = self::htmlspecialchars( $_GET[ $key ] ); 
  191.  
  192.         if( is_array( $value ) ) $value = $value[ 0 ]; 
  193.  
  194.         return $value; 
  195.     } 
  196.  
  197.     public static function sanitize_text_field( $data ) 
  198.     { 
  199.         if( is_array( $data ) ) { 
  200.             return array_map( array( 'self', 'sanitize_text_field' ), $data ); 
  201.         } 
  202.         return sanitize_text_field( $data ); 
  203.     } 
  204.  
  205.     public static function get_plugin_version( $plugin ) 
  206.     { 
  207.         $plugins = get_plugins(); 
  208.  
  209.         if( ! isset( $plugins[ $plugin ] ) ) return false; 
  210.  
  211.         return $plugins[ $plugin ][ 'Version' ]; 
  212.     } 
  213.  
  214.     public static function is_func_disabled( $function ) 
  215.     { 
  216.         if( ! function_exists( $function ) ) return true; 
  217.         $disabled = explode( ', ', ini_get( 'disable_functions' ) ); 
  218.         return in_array( $function, $disabled ); 
  219.     } 
  220.  
  221.     public static function maybe_unserialize( $original ) 
  222.     { 
  223.         // Repalcement for https://codex.wordpress.org/Function_Reference/maybe_unserialize 
  224.         if ( is_serialized( $original ) ) { 
  225.             // Ported with php5.2 support from https://magp.ie/2014/08/13/php-unserialize-string-after-non-utf8-characters-stripped-out/ 
  226.             $parsed = preg_replace_callback( '!s:(\d+):"(.*?)";!s', array( 'self', 'parse_utf8_serialized' ), $original ); 
  227.             $parsed = @unserialize( $parsed ); 
  228.  
  229.             return ( $parsed ) ? $parsed : unserialize( $original ); // Fallback if parse error. 
  230.         } 
  231.         return $original; 
  232.     } 
  233.      
  234.          
  235.     /** 
  236.      * Function to get this installation's TLS version 
  237.      *  
  238.      * Since 3.0 
  239.      *  
  240.      * @return float OR false 
  241.      */ 
  242.     public static function get_tls() 
  243.     { 
  244.         $php_ver = phpversion(); 
  245.         // If we have a php version lower than 5.6, bail. 
  246.         if( version_compare( $php_ver, '5.6.0', '<' ) ) return false; 
  247.         // Get the user's TLS version. 
  248.  
  249.         // If we have a php version of 7.0 or higher... 
  250.         if( version_compare( $php_ver, '7.0.0', '>=' ) ) { 
  251.             $meta = stream_get_meta_data( fopen( 'https://ninjaforms.com/', 'r' ) ); 
  252.             $tls = $meta[ 'crypto' ][ 'protocol' ];             
  253.         } 
  254.         // Otherwise (php version between 5.6 and 7.0)... 
  255.         else { 
  256.             $ctx = stream_context_create( array( 'ssl' => array( 
  257.                 'capture_session_meta' => TRUE 
  258.  ) ) ); 
  259.             $html = file_get_contents( 'https://ninjaforms.com/', FALSE, $ctx ); 
  260.             $meta = stream_context_get_options( $ctx ); 
  261.             $tls = $meta[ 'ssl' ][ 'session_meta' ][ 'protocol' ]; 
  262.             unset( $ctx ); 
  263.         } 
  264.         // If we got a TLS version number... 
  265.         if( false !== strpos( $tls, 'TLSv' ) ) { 
  266.             $ver = substr( $tls, strpos( $tls, 'TLSv' ) + 4 ); 
  267.             return floatval( $ver ); 
  268.         } else { 
  269.             return false; 
  270.         } 
  271.     } 
  272.  
  273.     private static function parse_utf8_serialized( $matches ) 
  274.     { 
  275.         if ( isset( $matches[2] ) ) { 
  276.             return 's:'.strlen($matches[2]).':"'.$matches[2].'";'; 
  277.         } 
  278.     } 
  279.  
  280. } // End Class WPN_Helper