Utils.php

Go to the documentation of this file.

<?php

namespace Combu;

class Utils {
    
    public static function IsIPv4($ip) {
        return !empty($ip) && (FALSE !== filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4));
    }
    
    public static function IsIPv6($ip) {
        return !empty($ip) && (FALSE !== filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6));
    }
    
    public static function DownloadUrl($url, $saveTo = NULL) {
        set_time_limit(0); // unlimited max execution time
        $result = "";
        try {
            if (function_exists("curl_init")) {
                $options = array(
                    CURLOPT_TIMEOUT =>  28800, // set this to 8 hours so we dont timeout on big files
                    CURLOPT_URL     => $url,
                    CURLOPT_RETURNTRANSFER => 1
                );
                $ch = curl_init();
                curl_setopt_array($ch, $options);
                $result = curl_exec($ch);
                curl_close($ch);
            } else if (ini_get('allow_url_fopen')) {
                $file = fopen($url, 'rb');
                if ($file) {
                    while (!feof($file)) {
                        $result .= fread($file, 8192);
                    }
                }
                fclose($file);
            } else {
                $result = file_get_contents($url);
            }
        } catch (Exception $ex) {
            $result = "";
        }
        if ($result && $saveTo && is_writable(dirname($saveTo))) {
            try {
                file_put_contents($saveTo, $result);
            } catch (Exception $ex) {
            }
        }
        return $result;
    }
    
    public static function GetAllFiles($root, $trimRoot = FALSE, $level = 0) {
        $handle = NULL;
        if (file_exists($root) && is_readable($root)) {
            $handle = opendir($root);
        }
        $dirs = array();
        $files = array();
        while ($handle && false !== ($entry = readdir($handle))) {
            if ($entry == "." || $entry == ".." || strcasecmp($entry, ".DS_Store") == 0 || strcasecmp($entry, "thumbs.db") == 0) {
                continue;
            }
            $entryPath = self::CombinePath($root, $entry);
            if (is_dir($entryPath)) {
                $dirs[] = $entryPath;
            } else {
                $files[] = $entryPath;
            }
        }
        ++$level;
        foreach ($dirs as $dir) {
            $files = array_merge(self::GetAllFiles($dir, FALSE, $level), $files);
        }
        if ($level == 0 && $trimRoot) {
            for ($i = 0; $i < count($files); ++$i) {
                $files[$i] = str_replace($root, "", $files[$i]);
                if (Utils::StartsWith($files[$i], "/")) {
                    $files[$i] = substr($files[$i], 1);
                }
            }
        }
        return $files;
    }
    
    public static function GetAllFolders($root, $recursive = FALSE, $trimRoot = FALSE, $level = 0) {
        $handle = NULL;
        if (file_exists($root) && is_dir($root) && is_readable($root)) {
            $handle = opendir($root);
        }
        $dirs = array();
        if ($handle) {
            while (false !== ($entry = readdir($handle))) {
                if (self::StartsWith($entry, ".") || is_file($entry)) {
                    continue;
                }
                $dir = self::CombinePath($root, $entry);
                $dirs[] = $dir;
                if ($recursive) {
                    $dirs = array_merge($dirs, self::GetAllFolders($dir, TRUE, $trimRoot, $level + 1));
                }
            }
            if ($level == 0 && $trimRoot) {
                for ($i = 0; $i < count($dirs); ++$i) {
                    $dirs[$i] = str_replace($root, "", $dirs[$i]);
                }
            }
        }
        return $dirs;
    }
    
    public static function HttpErrorCode($code = 401, $message = NULL) {
        ob_clean();
        http_response_code($code);
        if (!empty($message)) {
            echo $message;
        }
        exit();
    }
    
    public static function GetServerName() {
        $serverName = filter_input(INPUT_SERVER, "SERVER_NAME");
        if (empty($serverName) && isset($_SERVER["SERVER_NAME"])) {
            $serverName = $_SERVER["SERVER_NAME"];
        }
        return $serverName;
    }
    
    public static function GetServerUrl($url = "") {
        $protocol = "http";
        if (!empty(filter_input(INPUT_SERVER, "HTTPS")) || (isset($_SERVER["HTTPS"]) && !empty($_SERVER["HTTPS"]))) {
            $protocol .= "s";
        }
        $serverPort = filter_input(INPUT_SERVER, "SERVER_PORT");
        if (empty($serverPort) && isset($_SERVER["SERVER_PORT"])) {
            $serverPort = $_SERVER["SERVER_PORT"];
        }
        if (!empty($serverPort) && $serverPort != 80) {
            $serverPort = ":" . $serverPort;
        } else {
            $serverPort = "";
        }
        return self::CombineUrl($protocol . "://" . self::GetServerName() . $serverPort, self::CombineUrl(URL_ROOT, $url));
    }
    
    public static function GetUploadUrl($url = "") {
        return self::GetServerUrl(self::CombineUrl(URL_UPLOAD, $url));
    }
    
    public static function CombineUrl($path1, $path2) {
        return self::CombinePath($path1, $path2, "/");
    }
    
    public static function CombinePath($path1, $path2, $separator = DIRECTORY_SEPARATOR) {
        $path = $path1;
        if (!empty($path2)) {
            if ($separator && self::EndsWith($path, $separator)) {
                $path = substr($path, 0, strlen($path) - 1);
            }
            $path .= ($separator && !self::StartsWith($path2, $separator) ? $separator : "") . $path2;
        }
        return $path;
    }
    
    public static function GetDateTimeZoneUTC() {
        return new \DateTimeZone("Etc/UTC");
    }
    
    public static function GetCurrentDateTime($timezone = NULL) {
        if (!$timezone) {
            $timezone = self::GetDateTimeZoneUTC();
        }
        return new \DateTime("now", $timezone);
    }
    
    public static function GetCurrentDateTimeFormat($format = "Y-m-d H:i:s", $timezone = NULL) {
        $now = self::GetCurrentDateTime($timezone);
        return $now->format($format);
    }
    
    public static function GetClientIP() {
        $ip = filter_input(INPUT_SERVER, "REMOTE_ADDR");
        if (empty($ip) && isset($_SERVER["REMOTE_ADDR"])) {
            $ip = $_SERVER["REMOTE_ADDR"];
        }
        return $ip;
    }
    
    public static function TicksToTime($ticks) {
        $mktime = (($ticks - 621355968000000000) / 10000000);
        $mktime -= 60 * 120;
        return $mktime;
    }
    public static function TimeToTicks($time) {
        $time += 60 * 120;
        return number_format(($time * 10000000) + 621355968000000000 , 0, '.', '');
    }
    public static function StringToTicks($str) {
        return time_to_ticks(strtotime($str));
    }
    
    public static function NewGUID() {
        return sprintf('%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
                // 32 bits for "time_low"
                mt_rand(0, 0xffff), mt_rand(0, 0xffff),
                // 16 bits for "time_mid"
                mt_rand(0, 0xffff),
                // 16 bits for "time_hi_and_version",
                // four most significant bits holds version number 4
                mt_rand(0, 0x0fff) | 0x4000,
                // 16 bits, 8 bits for "clk_seq_hi_res",
                // 8 bits for "clk_seq_low",
                // two most significant bits holds zero and one for variant DCE1.1
                mt_rand(0, 0x3fff) | 0x8000,
                // 48 bits for "node"
                mt_rand(0, 0xffff), mt_rand(0, 0xffff), mt_rand(0, 0xffff)
        );
    }
    
    public static function RedirectTo ($url = "") {
        global $Database;
        $Database->CloseConnection();
        if (!$url)
            $url = $_SERVER["PHP_SELF"];
        header("Location: $url");
        exit();
    }
    public static function RedirectToSelf () {
        global $Database;
        $Database->CloseConnection();
        $url = $_SERVER["PHP_SELF"];
        $queryString = "";
        foreach ($_GET as $key => $value) {
            $queryString .= ($queryString ? "&" : "") . "$key=" . urlencode($value);
        }
        $url .= "?" . $queryString;
        header("Location: $url");
        exit();
    }
    
    public static function ServerResponseRequired() {
        return (defined("RESPONSE_ENCRYPTED") && RESPONSE_ENCRYPTED === TRUE);
    }

    public static function EchoJson($text, $encodeJson = FALSE, $encryptResponse = FALSE) {
        global $Database;
        $Database->CloseConnection();
        if ($encodeJson === TRUE) {
            $text = json_encode($text);
        }
        ob_clean();
        header("Access-Control-Allow-Credentials:true");
        header("Access-Control-Allow-Headers:Accept, X-Access-Token, X-Application-Name, X-Request-Sent-Time");
        header("Access-Control-Allow-Methods:GET, POST, OPTIONS");
        header("Access-Control-Allow-Origin:*");
        header("Content-Type:text/json");
        if ($encryptResponse && self::ServerResponseRequired()) {
            echo json_encode(array( "t" => self::GetCurrentDateTimeFormat(), "d" => clientEncrypt($text) ));
        } else {
            echo $text;
        }
        exit();
    }

    public static function EchoXml($xml, $encryptResponse = FALSE) {
        global $Database;
        $Database->CloseConnection();
        ob_clean();
        header("Access-Control-Allow-Credentials:true");
        header("Access-Control-Allow-Headers:Accept, X-Access-Token, X-Application-Name, X-Request-Sent-Time");
        header("Access-Control-Allow-Methods:GET, POST, OPTIONS");
        header("Access-Control-Allow-Origin:*");
        header("Content-Type:text/xml");
        if ($encryptResponse && self::ServerResponseRequired()) {
            echo sprintf("<response><t>%s</t><d>%s</d></response>", htmlentities(self::GetCurrentDateTimeFormat()), htmlentities(clientEncrypt($xml)));
        } else {
            echo $xml;
        }
        exit();
    }
    
    public static function EchoUnauthorized($text = "") {
        if (!$text) {
            $text = ErrorMessage::Get(ERROR_UNAUTHORIZED_REQUEST);
        }
        ob_clean();
        http_response_code(401);
        echo $text;
        exit();
    }

    public static function StartsWith($text, $search, $ignoreCase = false) {
        $s = substr($text, 0, strlen($search));
        if ($ignoreCase === true) {
            return (strtolower($s) == strtolower($search));
        }
        return ($s == $search);
    }

    public static function EndsWith($text, $search, $ignoreCase = false) {
        $s = substr($text, -strlen($search));
        if ($ignoreCase === true) {
            return (strtolower($s) == strtolower($search));
        }
        return ($s == $search);
    }

    public static function GetTimestamp($data, $add_days = 0) {
        if (strpos($data, " ") === false) {
            $a_data = $data;
            $a_time = "00:00";
        } else {
            $a_data = substr($data, 0, strpos($data, " "));
            $a_time = substr($data, strpos($data, " ") + 1);
        }
        $a_data = explode("/", str_replace("-", "/", $a_data));
        $a_time = explode(":", str_replace(".", ":", $a_time));
        if (strlen($a_data[0]) == 4) {
            // From ISO format (YYYY/MM/DD)
            $timestamp = mktime($a_time[0], $a_time[1], count($a_time) == 3 ? $a_time[2] : 0, $a_data[1], $add_days + $a_data[2], $a_data[0]);
        } else {
            // From ITA format (DD/MM/YYYY)
            $timestamp = mktime($a_time[0], $a_time[1], count($a_time) == 3 ? $a_time[2] : 0, $a_data[1], $add_days + $a_data[0], $a_data[2]);
        }
        return $timestamp;
    }
    
    public static function IsValidDate($text) {
        $datebit = "";
        if (preg_match('/^(\d{4})-(\d{2})-(\d{2})$/', $text, $datebit)) {
            return checkdate($datebit[2], $datebit[3], $datebit[1]);
        }
        return false;
    }
    
    public static function IsValidTime($text) {
        $datebit = "";
        if (preg_match('/^(\d{2}):(\d{2})$/', $text, $datebit)) {
            return ($datebit[1] >= 0 && $datebit[1] <= 59) && ($datebit[2] >= 0 && $datebit[2] <= 59);
        } else if (preg_match('/^(\d{2}):(\d{2}):(\d{2})$/', $text, $datebit)) {
            return ($datebit[1] >= 0 && $datebit[1] <= 59) && ($datebit[2] >= 0 && $datebit[2] <= 59) && ($datebit[3] >= 0 && $datebit[3] <= 59);
        }
        return false;
    }

    public static function ConvertSizeFromBytes($bytes, $to = NULL) {
        $float = floatval($bytes);
        switch ($to) {
            case 'Kb' :            // Kilobit
                $float = ( $float * 8 ) / 1024;
                break;
            case 'b' :             // bit
                $float *= 8;
                break;
            case 'GB' :            // Gigabyte
                $float /= 1024;
            case 'MB' :            // Megabyte
                $float /= 1024;
            case 'KB' :            // Kilobyte
                $float /= 1024;
            default :              // byte
        }
        unset($bytes, $to);
        return round($float, 1);
    }

    public static function ExtractSearchKeywords($searchText) {
        $keys = array();
        $text = preg_replace("/\s{2,}/", " ", $searchText);
        $multiple = array();
        preg_match_all("|\"[^\"]+\"|", $text, $multiple);
        foreach ($multiple[0] as $key) {
            $text = str_replace($key, "", $text);
            $keys[] = str_replace('"', '', $key);
        }
        $arr_text = explode(" ", $text);
        foreach ($arr_text as $s) {
            if (!empty($s) && !in_array($s, $keys)) {
                $keys[] = $s;
            }
        }
        return $keys;
    }

    public static function CalcPercentage($total, $count) {
        if ($total == 0 || $count == 0) {
            return 0;
        }
        $perc = number_format((floatval($count) / floatval($total)) * 100, 2);
        if (substr($perc, -2) == "00") {
            return substr($perc, 0, strlen($perc) - 3);
        }
        if (substr($perc, -1) == "0") {
            return substr($perc, 0, strlen($perc) - 1);
        }
        return $perc;
    }

    public static function GetPageOffset($page, $limit) {
        if ($page > 1) {
            return $limit * ($page - 1);
        }
        return 0;
    }

    public static function GetPagesCount($count, $limit) {
        if ($limit > 0) {
            return ceil($count / $limit);
        }
        return 0;
    }

    public static function GetValidFilename($oldName, $newExt = "") {
        $newName = "";
        $name = $oldName;
        $ext = Utils::GetFilenameExtension($name);
        if ($ext != "") {
            $name = substr($name, 0, strlen($name) - strlen($ext));
        }
        for ($i = 0; $i < strlen($name); $i++) {
            $char = substr($name, $i, 1);
            if (!preg_match("/^[a-zA-Z0-9._-]$/", $char)) {
                $char = "_";
            }
            $newName .= $char;
        }
        $newName .= ($newExt != "" ? $newExt : $ext);
        return $newName;
    }

    public static function GetFilenameExtension($filename) {
        $i = strrpos($filename, ".");
        if ($i === false) {
            return "";
        }
        return substr($filename, $i);
    }

    public static function GetTempname($fileExt = ".tmp") {
        $tmp_name = md5(microtime()) . $fileExt;
        return $tmp_name;
    }

    public static function GenerateRandomCode($length = 0) {
        if ($length <= 0) {
            if (defined("RANDOM_CODE_LENGTH") && RANDOM_CODE_LENGTH > 0) {
                $length = intval(RANDOM_CODE_LENGTH);
            } else {
                $length = 10;
            }
        }
        $code = "";
        if (defined("RANDOM_CODE_CHARS") && RANDOM_CODE_CHARS) {
            $chars = RANDOM_CODE_CHARS;
        } else {
            $chars = "bcdfghjklmnpqrstvwxzBCDFGHJKLMNPQRSTVWXZ0123456789";
        }
        while (strlen($code) < $length) {
            $code .= substr($chars, rand(0, strlen($chars) - 1), 1);
        }
        return $code;
    }

    public static function IsValidEmail($email) {
        $regex = '/^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,3})$/i';
        return preg_match($regex, $email);
    }

    public static function JsonEncodeRowsMessage($rows, $count, $pagesCount = NULL, $extraParams = NULL) {
        if (count($rows) > 0 && $rows[0] !== NULL && is_subclass_of($rows[0], "DataClass")) {
            $temp = array();
            foreach ($rows as $r) {
                $temp[] = $r->ToArray();
            }
            $rows = $temp;
        }
        for ($i = 0; $i < count($rows); $i++) {
            foreach ($rows[$i] as $k => $v) {
                if (is_array($v) || is_object($v)) {
                    continue;
                }
                if (is_numeric($v) || is_bool($v)) {
                    continue;
                } elseif ($v == null || $v == "NULL") {
                    $rows[$i][$k] = "";
                } elseif (substr($v, 0, 10) == "00/00/0000" || substr($v, 0, 10) == "0000-00-00") {
                    $rows[$i][$k] = "";
                }
            }
        }
        $result = array("total" => $count, "results" => $rows);
        if ($pagesCount !== NULL) {
            $result["pages"] = $pagesCount;
        }
        if ($extraParams !== NULL && is_array($extraParams)) {
            $result = array_merge($result, $extraParams);
        }
        return json_encode($result);
    }

    public static function JsonEncodeSuccessMessage($success = true, $message = "", $errors = array()) {
        return json_encode(array("success" => $success, "message" => $message, "errors" => $errors));
    }
    
    public static function FillObjectFromRequest(&$obj) {
        $props = array_keys(get_class_vars(get_class($obj)));
        foreach ($props as $prop) {
            $requestValue = filter_input(INPUT_POST, $prop);
            if (is_null($requestValue)) {
                $requestValue = filter_input(INPUT_GET, $prop);
            }
            if (!is_null($requestValue)) {
                $obj->$prop = $requestValue;
            }
        }
    }

    public static function FillObjectFromRow(&$obj, $row, $stripSlashes = false, $callbackOnExists = false) {
        $props = get_class_vars(get_class($obj));
        foreach ($props as $prop => $value) {
            if (array_key_exists($prop, $row)) {
                if (!$callbackOnExists) {
                    $value = ($stripSlashes ? trim(stripslashes($row[$prop])) : $row[$prop]);
                    /* if ($stripSlashes && self::IsUtf8($value)) {
                      $value = utf8_decode($value);
                      } */
                    $obj->$prop = $value;
                } else {
                    $obj->$callbackOnExists($prop, $row[$prop]);
                }
            }
        }
    }

    public static function ObjectToArray($obj) {
        $array = array();
        if (is_a($obj, "stdClass")) {
            $variables = get_object_vars($obj);
            $keys = array_keys($variables);
            foreach ($keys as $k) {
                $array[$k] = $obj->$k;
            }
        } else {
            $props = get_class_vars(get_class($obj));
            foreach ($props as $prop => $value) {
                $array[$prop] = $obj->$prop;
            }
        }
        return $array;
    }
}