346 lines
9.9 KiB
PHP
346 lines
9.9 KiB
PHP
<?php
|
|
|
|
namespace app\common\services;
|
|
|
|
use Illuminate\Filesystem\Filesystem;
|
|
use Illuminate\Support\Facades\Cookie;
|
|
use Illuminate\Support\Facades\DB;
|
|
use Log;
|
|
use Carbon\Carbon;
|
|
use Illuminate\Support\Str;
|
|
use Storage as LaravelStorage;
|
|
|
|
class Utils
|
|
{
|
|
/**
|
|
* Returns the client IP address.
|
|
*
|
|
* This method is defined because Symfony's Request::getClientIp() needs "setTrustedProxies()"
|
|
* which sucks when load balancer is enabled.
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function getClientIp()
|
|
{
|
|
if (!empty($_SERVER['HTTP_CLIENT_IP'])) {
|
|
$ip = $_SERVER['HTTP_CLIENT_IP'];
|
|
} elseif (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {
|
|
$ip = $_SERVER['HTTP_X_FORWARDED_FOR'];
|
|
} else {
|
|
$ip = $_SERVER['REMOTE_ADDR'];
|
|
}
|
|
|
|
return $ip;
|
|
}
|
|
|
|
/**
|
|
* Checks whether the request is secure or not.
|
|
* True is always returned when "X-Forwarded-Proto" header is set.
|
|
*
|
|
* This method is defined because Symfony's Request::isSecure() needs "setTrustedProxies()"
|
|
* which sucks when load balancer is enabled.
|
|
*
|
|
* @return bool
|
|
*/
|
|
public static function isRequestSecure()
|
|
{
|
|
if (isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] == 'on')
|
|
return true;
|
|
|
|
if (!empty($_SERVER['HTTP_X_FORWARDED_PROTO']) && $_SERVER['HTTP_X_FORWARDED_PROTO'] == 'https')
|
|
return true;
|
|
|
|
if (!empty($_SERVER['HTTP_X_FORWARDED_SSL']) && $_SERVER['HTTP_X_FORWARDED_SSL'] == 'on')
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Compares two "PHP-standardized" version number strings.
|
|
* Unlike version_compare(), this method will determine that versions with suffix are lower.
|
|
*
|
|
* e.g. 3.2-beta > 3.2-alpha
|
|
* 3.2 > 3.2-beta
|
|
* 3.2 > 3.2-pre-release
|
|
* 3.2 > 3.2-pr8
|
|
*
|
|
* @param string $version1
|
|
* @param string $version2
|
|
* @param string $operator
|
|
* @return mixed
|
|
*/
|
|
public static function versionCompare($version1, $version2, $operator = null)
|
|
{
|
|
$versions = [$version1, $version2];
|
|
|
|
// pre-processing for version contains hyphen
|
|
foreach ([0, 1] as $offset) {
|
|
if (false !== ($result = self::parseVersionWithHyphen($versions[$offset]))) {
|
|
$versions[$offset] = $result;
|
|
} else {
|
|
$versions[$offset] = ['main' => $versions[$offset], 'sub' => ''];
|
|
}
|
|
}
|
|
|
|
if (version_compare($versions[0]['main'], $versions[1]['main'], '=')) {
|
|
$sub1 = $versions[0]['sub'];
|
|
$sub2 = $versions[1]['sub'];
|
|
|
|
// v3.2-pr < v3.2
|
|
if ($sub1 != "" || $sub2 != "") {
|
|
// if both of sub-versions are not empty
|
|
if ($sub1 != "" && $sub2 != "") {
|
|
return version_compare($sub1, $sub2, $operator);
|
|
} else {
|
|
$result = version_compare($sub1, $sub2, $operator);
|
|
// reverse the result since version_compare() will determine that "beta" > ""
|
|
return ($operator == "=") ? $result : !$result;
|
|
}
|
|
}
|
|
}
|
|
|
|
return version_compare($versions[0]['main'], $versions[1]['main'], $operator);
|
|
}
|
|
|
|
public static function parseVersionWithHyphen($version)
|
|
{
|
|
preg_match('/([^-]*)-(.*)/', $version, $matches);
|
|
|
|
if (isset($matches[2])) {
|
|
return [
|
|
'main' => $matches[1],
|
|
'sub' => $matches[2]
|
|
];
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Rename uploaded file
|
|
*
|
|
* @param array $file files uploaded via HTTP POST
|
|
* @return string $hash sha256 hash of file
|
|
*/
|
|
public static function upload($file)
|
|
{
|
|
$path = 'tmp'.time();
|
|
$absolute_path = storage_path("textures/$path");
|
|
|
|
try {
|
|
if (false === move_uploaded_file($file['tmp_name'], $absolute_path)) {
|
|
throw new \Exception('Failed to remove uploaded files, please check the permission', 1);
|
|
}
|
|
} catch (\Exception $e) {
|
|
Log::warning("Failed to move uploaded file, $e");
|
|
} finally {
|
|
if (file_exists($absolute_path)) {
|
|
$hash = hash_file('sha256', $absolute_path);
|
|
|
|
if (!LaravelStorage::disk('textures')->has($hash)) {
|
|
LaravelStorage::disk('textures')->move($path, $hash);
|
|
} else {
|
|
// delete the temp file
|
|
unlink($absolute_path);
|
|
}
|
|
|
|
return $hash;
|
|
} else {
|
|
Log::warning("Failed to upload file $path");
|
|
}
|
|
}
|
|
}
|
|
|
|
public static function download($url, $path)
|
|
{
|
|
@set_time_limit(0);
|
|
|
|
touch($path);
|
|
|
|
Log::info("[File Downloader] Download started, source: $url");
|
|
Log::info("[File Downloader] ======================================");
|
|
|
|
$ctx = stream_context_create([
|
|
"ssl"=>[
|
|
"verify_peer"=>false,
|
|
"verify_peer_name"=>false,
|
|
]
|
|
]);
|
|
|
|
if ($fp = fopen($url, "rb", false, $ctx)) {
|
|
|
|
if (!$download_fp = fopen($path, "wb", false, $ctx)) {
|
|
return false;
|
|
}
|
|
|
|
while (!feof($fp)) {
|
|
|
|
if (!file_exists($path)) {
|
|
// cancel downloading if destination is no longer available
|
|
fclose($download_fp);
|
|
|
|
return false;
|
|
}
|
|
|
|
Log::info("[Download] 1024 bytes wrote");
|
|
fwrite($download_fp, fread($fp, 1024 * 8 ), 1024 * 8);
|
|
}
|
|
|
|
fclose($download_fp);
|
|
fclose($fp);
|
|
|
|
Log::info("[File Downloader] Finished downloading, data stored to: $path");
|
|
Log::info("[File Downloader] ===========================================");
|
|
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static function getRemoteFileSize($url)
|
|
{
|
|
$regex = '/^Content-Length: *+\K\d++$/im';
|
|
|
|
if (!$fp = @fopen($url, 'rb')) {
|
|
return false;
|
|
}
|
|
|
|
if (
|
|
isset($http_response_header) &&
|
|
preg_match($regex, implode("\n", $http_response_header), $matches)
|
|
) {
|
|
return (int)$matches[0];
|
|
}
|
|
|
|
return strlen(stream_get_contents($fp));
|
|
}
|
|
|
|
public static function getTimeFormatted($timestamp = 0)
|
|
{
|
|
return ($timestamp == 0) ? Carbon::now()->toDateTimeString() : Carbon::createFromTimestamp($timestamp)->toDateTimeString();
|
|
}
|
|
|
|
/**
|
|
* Replace content of string according to given rules.
|
|
*
|
|
* @param string $str
|
|
* @param array $rules
|
|
* @return string
|
|
*/
|
|
public static function getStringReplaced($str, $rules)
|
|
{
|
|
foreach ($rules as $search => $replace) {
|
|
$str = str_replace($search, $replace, $str);
|
|
}
|
|
return $str;
|
|
}
|
|
|
|
/**
|
|
* Convert error number of uploading files to human-readable text.
|
|
*
|
|
* @param int $errno
|
|
* @return string
|
|
*/
|
|
public static function convertUploadFileError($errno = 0)
|
|
{
|
|
$phpFileUploadErrors = [
|
|
0 => 'There is no error, the file uploaded with success',
|
|
1 => 'The uploaded file exceeds the upload_max_filesize directive in php.ini',
|
|
2 => 'The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the HTML form',
|
|
3 => 'The uploaded file was only partially uploaded',
|
|
4 => 'No file was uploaded',
|
|
6 => 'Missing a temporary folder',
|
|
7 => 'Failed to write file to disk.',
|
|
8 => 'A PHP extension stopped the file upload.',
|
|
];
|
|
|
|
return $phpFileUploadErrors[$errno];
|
|
}
|
|
|
|
public static function fieldexists($table, $field)
|
|
{
|
|
$prefix = DB::getTablePrefix();
|
|
$tb = $prefix . $table;
|
|
|
|
$res = DB::select("Describe {$tb} {$field}");
|
|
|
|
if (!empty($res)) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static function dataEncrypt(&$data)
|
|
{
|
|
foreach ($data as $key => &$val) {
|
|
if (!empty($val)) {
|
|
switch ($key) {
|
|
case 'alipay_app_id':
|
|
case 'rsa_private_key':
|
|
case 'rsa_public_key':
|
|
case 'alipay_number':
|
|
case 'alipay_name':
|
|
$val = encrypt($val);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static function dataDecrypt(&$data)
|
|
{
|
|
foreach ($data as $key => &$val) {
|
|
if (!empty($val)) {
|
|
switch ($key) {
|
|
case 'alipay_app_id':
|
|
case 'rsa_private_key':
|
|
case 'rsa_public_key':
|
|
case 'alipay_number':
|
|
case 'alipay_name':
|
|
$val = decrypt($val);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static function mkdirs($path)
|
|
{
|
|
$filesystem = app(Filesystem::class);
|
|
|
|
if (!$filesystem->isDirectory($path)) {
|
|
$filesystem->makeDirectory($path, 0755, true);
|
|
}
|
|
|
|
return $filesystem->isDirectory($path);
|
|
}
|
|
|
|
/**
|
|
* 清除uniacid
|
|
*
|
|
*/
|
|
public static function removeUniacid()
|
|
{
|
|
Cookie::queue('uniacid',null,time() - 2160000, '/');
|
|
Cookie::queue('uniacid',null,time() - 2160000, '/admin');
|
|
Cookie::queue('uniacid',null,time() - 2160000,'/admin/shop');
|
|
|
|
}
|
|
|
|
/**
|
|
* 保存uniacid
|
|
*/
|
|
public static function addUniacid($uniacid = null)
|
|
{
|
|
if (is_null($uniacid)) {
|
|
$uniacid = request()->uniacid;
|
|
}
|
|
Cookie::queue('uniacid',$uniacid,time() + 2160000, '/admin');
|
|
Cookie::queue('uniacid',$uniacid,time() + 2160000,'/admin/shop');
|
|
|
|
}
|
|
}
|