?
GR0V Shell
GR0V shell
Linux www.koreapackagetour.com 2.6.32-042stab145.3 #1 SMP Thu Jun 11 14:05:04 MSK 2020 x86_64
<?php
/**
* ------------------------------------------------------------------------
* JA Extenstion Manager Component for J25 & J3
* ------------------------------------------------------------------------
* Copyright (C) 2004-2011 J.O.O.M Solutions Co., Ltd. All Rights Reserved.
* @license - GNU/GPL, http://www.gnu.org/licenses/gpl.html
* Author: J.O.O.M Solutions Co., Ltd
* Websites: http://www.joomlart.com - http://www.joomlancers.com
* ------------------------------------------------------------------------
*/
// no direct access
//defined ( '_JEXEC' ) or die ( 'Restricted access' );
if (!defined('_JA'))
define("_JA", "JoomlArt Enterprise");
define("_JA_ROOT", realpath(dirname(__FILE__)));
jimport('joomla.filesystem.file');
jimport('joomla.filesystem.folder');
require_once (_JA_ROOT . "/jaupdater/JAUpdater.php");
if (defined('_JEXEC')) {
include_once (_JA_ROOT . "/config_joomla.php");
} else {
include_once (_JA_ROOT . "/config.php");
}
class UpdaterClient
{
var $config, $lastAction;
function UpdaterClient()
{
global $config;
$this->config = new UpdaterConfig();
if (!empty($config)) {
$this->config->merge($config);
}
}
function invokeService($message, $product = null)
{
$messageData = "json=" . json_encode($message);
$content = $message->content;
$account = $content["args"]["account"];
$serviceUrl = $account->ws_uri;
$result = NetworkHelper::doPOST($serviceUrl, $messageData);
$result = $this->getJsonObject($result);
if ($result === false) {
//jaucRaiseMessage("Responding an error from Web Service", true);
return false;
} else if (!empty($result->error)) {
jaucRaiseMessage($result->error, true);
return false;
//throw new Exception('Invoking service ['.$message->content->service.'] error '.$result->error);
} else {
return $result->response;
}
}
/**
* Build service message
*
* @param $from string identify of this host
* @param $to string name of web service
* @param $content object service call and arguments
*
* @return Message
*/
function buildMessage($content, $from = null, $to = null)
{
$args = (isset($content["args"])) ? $content["args"] : array();
$product = (isset($args["product"])) ? $args["product"] : null;
if (!isset($args["account"]) || !is_object($args["account"])) {
$account = new stdClass();
$account->ws_uri = $this->getServiceUrl($product);
$account->ws_user = $this->getServiceUsername($product);
$account->ws_pass = $this->getServicePassword($product);
} else {
$account = $args["account"];
}
$account->user_domain = $_SERVER['SERVER_NAME'];
$content["args"]["account"] = $account;
$from = empty($from) ? $_SERVER["REMOTE_ADDR"] : $from;
$to = empty($to) ? "JAUpdater Web Service" : $to;
return (new Message($content, $from, $to));
}
function authUser($service)
{
$content["service"] = "authUser";
$content["args"]["account"] = $service;
$product = null;
$result = $this->invokeService($this->buildMessage($content), $product);
return $result;
}
/**
*
* @param $data string json string
*
* @return object
*/
function getJsonObject($data)
{
$result = json_decode($data["content"]);
if (!empty($result) && !empty($result->content)) {
return $result->content;
} else {
//echo $data["content"];
return false;
//throw new Exception("Invalid JSON data");
}
}
function isLocalMode($product = null)
{
if (is_object($product) && !empty($product->ws_mode)) {
return ($product->ws_mode == 'local') ? 1 : 0;
} else {
return ($this->config->get("WS_MODE") == 'local') ? 1 : 0;
}
}
function getServiceUrl($product = null)
{
if (is_object($product) && !empty($product->ws_uri)) {
return $product->ws_uri;
} else {
//default value
return $this->config->get("WS_URI");
}
}
function getServiceUsername($product = null)
{
if (is_object($product) && !empty($product->ws_user)) {
return $product->ws_user;
} else {
//default value
return $this->config->get("WS_USER");
}
}
function getServicePassword($product = null)
{
if (is_object($product) && !empty($product->ws_pass)) {
return $product->ws_pass;
} else {
//default value
return $this->config->get("WS_PASS");
}
}
function getProduct($product)
{
$pro = new jaProducts($product, $this->config);
return $pro;
}
/**
* Enter description here...
*
* @param unknown_type $refresh
* @return unknown
*/
function getListProducts($refresh = 0)
{
//cache client
$FileSystemHelper = new FileSystemHelper();
$dataDir = $FileSystemHelper->clean(JA_WORKING_DATA_FOLDER);
$productsFile = $dataDir . "jaupdater.products.json";
$productList = null;
if (file_exists($productsFile) && !$refresh) {
$updateTime = filectime($productsFile);
$currentTime = time();
$cacheTimelife = 3 * 24 * 60 * 60; //3 days
if ($updateTime + $cacheTimelife > $currentTime) {
$productList = json_decode(file_get_contents($productsFile));
}
}
if (empty($productList)) {
$content["service"] = "listProducts";
$content["args"]["refresh"] = $refresh;
$result = $this->invokeService($this->buildMessage($content));
if ($result === false) {
jaucRaiseMessage("Fail to get list of products.");
return false;
} else {
$productList = $result;
//update cache
JFile::write($productsFile, json_encode($productList));
}
}
return $productList;
}
function getNewerVersions($product)
{
if ($this->isLocalMode($product)) {
return $this->getNewerVersionsLocal($product);
}
$content["service"] = "getNewerVersions";
$pro = new jaProducts($product, $this->config);
// Remove some unneeded information
$content["args"]["product"] = $pro->getInfo();
$result = $this->invokeService($this->buildMessage($content), $product);
return $result;
}
/**
* @return same result with getNewerVersions but getting information from local repo
*/
function getNewerVersionsLocal($product)
{
if (!($productDir = $this->getLocalVersionsPath($product))) {
return false;
}
if (!JFolder::exists($productDir)) {
return false;
} else {
$obj = new stdClass();
$handle = opendir($productDir);
$pro = new jaProducts($product, $this->config);
while (($entry = readdir($handle)) !== false) {
if (JFolder::exists($productDir . $entry.'/') && $entry != '.' && $entry != '..') {
$result = $this->isNewerVersion($entry, $product->version);
if ($result) {
$aVersions = $pro->_parseListVersions($productDir . $entry.'/'.basename($pro->configFile));
$ver = new stdClass();
$ver->type = $product->type;
$ver->name = $product->name;
$ver->extKey = $product->extKey;
$ver->version = $entry;
if ($result == 2) {
$ver->notSure = 1;
}
if (isset($aVersions[$entry]) && isset($aVersions[$entry]['changelogUrl'])) {
$ver->changelogUrl = $aVersions[$entry]['changelogUrl'];
}
$obj->$entry = $ver;
}
}
}
closedir($handle);
return $obj;
}
}
function buildDiff($product, $newVersion)
{
if ($this->isLocalMode($product)) {
return $this->buildDiffLocal($product, $newVersion);
}
$pro = new jaProducts($product, $this->config, true);
$content["service"] = "buildDiff";
$content["args"]["product"] = $pro->getFullInfo();
$content["args"]["newVersion"] = $newVersion;
$result = $this->invokeService($this->buildMessage($content), $product);
return $result;
}
/**
* @return same result with buildDiff but getting information from local repo
*/
function buildDiffLocal($product, $newVersion)
{
if (!($productDir = $this->getLocalVersionsPath($product))) {
return false;
}
//
$newVerDir = $productDir . $newVersion.'/';
if (!JFolder::exists($newVerDir)) {
return false;
}
$vUpgrade = new stdClass();
$vUpgrade->crc = $this->getVersionChecksum($newVerDir);
//
$orgVerDir = $productDir . $product->version.'/';
if (JFolder::exists($orgVerDir)) {
$vServer = new stdClass();
$vServer->crc = $this->getVersionChecksum($orgVerDir);
}
//
$pro = new jaProducts($product, $this->config, true);
$oldPro = $pro->getFullInfo();
//
$compare = new jaCompareTool();
if (isset($vServer)) {
return $compare->checkToUpgrade($oldPro, $vServer, $vUpgrade);
} else {
return $compare->checkToBuildUpgradePackage($oldPro, $vUpgrade);
}
}
function getFileContent($product, $version, $file)
{
if ($this->isLocalMode($product)) {
return $this->getFileContentLocal($product, $version, $file);
}
$pro = new jaProducts($product, $this->config);
$content["service"] = "getFileContent";
$content["args"]["product"] = $pro->getInfo();
$content["args"]["version"] = $version;
$content["args"]["file"] = $file;
$result = $this->invokeService($this->buildMessage($content), $product);
return $result;
}
function getFileContentLocal($product, $version, $file)
{
$product->version = $version;
$location = $this->getLocalVersionPath($product);
$file = $location . $file;
if (JFile::exists($file)) {
return file_get_contents($file);
} else {
return false;
}
}
function buildDiffFilesConflicted($product)
{
$pro = new jaProducts($product, $this->config);
$FileSystemHelper = new FileSystemHelper();
$diffFolder = $product->diffFolder;
$diffFile = $product->diffFile;
$titleLive = "Live file";
$fileLive = $pro->getFilePath($diffFile);
if (!JFile::exists($fileLive)) {
$titleLive = "Removed";
$strLive = "";
} else {
$strLive = file_get_contents($fileLive);
}
$titleBackup = "Backup file";
$fileBackup = $this->getLocalConflictPath($pro->getInfo(), $diffFolder) . $diffFile;
$fileBackup = $FileSystemHelper->clean($fileBackup);
$strBackup = file_get_contents($fileBackup);
$diff = new jaDiffTool();
$objLeft = $diff->buildObject($titleLive, $fileLive, $strLive, 1);
$objRight = $diff->buildObject($titleBackup, $fileBackup, $strBackup, 0);
$result = $diff->compare($objLeft, $objRight, 'string');
return $result;
}
function buildDiffFiles($product, $newVersion)
{
if ($this->isLocalMode($product)) {
return $this->buildDiffFilesLocal($product, $newVersion);
}
$pro = new jaProducts($product, $this->config);
$diffType = isset($product->diffType) ? $product->diffType : 'LN';
$diffFile = $product->diffFile;
$titleLive = "Current file (The file of version {$product->version} and modified by you)";
$titleOrig = "Original file (The file of version {$product->version})";
$titleNew = "New file (The file of new version {$newVersion})";
$fileLive = $pro->getFilePath($diffFile);
$fileOrig = "Remote File";
$fileNew = "Remote File";
if (JFile::exists($fileLive)) {
$strLive = file_get_contents($fileLive);
} else {
$strLive = '';
$titleLive = "Current file (The file of version {$product->version} and modified by you) <span style=\"color:red;\">Removed</span>";
}
$strOrig = $this->getFileContent($product, $product->version, $diffFile);
if ($strOrig === false) {
//If not found original version on server
//system will compare live version (of user' site) with new version (on server)
$strOrig = $strLive;
$fileOrig = $fileLive;
$titleOrig = $titleLive;
}
$strNew = $this->getFileContent($product, $newVersion, $diffFile);
/*********/
$arrayTypes = array('L' => 'Live', 'N' => 'New', 'O' => 'Orig');
$suffix1 = $arrayTypes[substr($diffType, 0, 1)];
$suffix2 = $arrayTypes[substr($diffType, 1, 1)];
$title1 = ${'title' . $suffix1};
$file1 = ${'file' . $suffix1};
$str1 = ${'str' . $suffix1};
$title2 = ${'title' . $suffix2};
$file2 = ${'file' . $suffix2};
$str2 = ${'str' . $suffix2};
/*********/
if ($str1 !== false && $str2 !== false) {
$diff = new jaDiffTool();
$objLeft = $diff->buildObject($title1, $file1, $str1, 0);
$objRight = $diff->buildObject($title2, $file2, $str2, 0);
$result = $diff->compare($objLeft, $objRight, 'string');
return $result;
} else {
return false;
}
}
function buildDiffFilesLocal($product, $newVersion)
{
$FileSystemHelper = new FileSystemHelper();
if (!($productDir = $this->getLocalVersionsPath($product))) {
return false;
}
$pro = new jaProducts($product, $this->config);
$diffType = isset($product->diffType) ? $product->diffType : 'LN';
$diffFile = $product->diffFile;
/**
* (L) = Files of Live version on user site.
* (O) = Original files of live version.
* (N) = New Version Files.
*/
$titleLive = "Current file (The file of version {$product->version} and modified by you)";
$titleOrig = "Original file (The file of version {$product->version})";
$titleNew = "New file (The file of new version {$newVersion})";
$fileLive = $pro->getFilePath($diffFile);
$fileOrig = $FileSystemHelper->clean($productDir . $product->version.'/'.$diffFile);
$fileNew = $FileSystemHelper->clean($productDir . $newVersion.'/'.$diffFile);
if (!JFile::exists($fileOrig)) {
//missing current version on local repository
//=> using live file to compare
$fileOrig = $fileLive;
$titleOrig = $titleLive;
}
/*********/
$arrayTypes = array('L' => 'Live', 'N' => 'New', 'O' => 'Orig');
$suffix1 = $arrayTypes[substr($diffType, 0, 1)];
$suffix2 = $arrayTypes[substr($diffType, 1, 1)];
$title1 = ${'title' . $suffix1};
$file1 = ${'file' . $suffix1};
$title2 = ${'title' . $suffix2};
$file2 = ${'file' . $suffix2};
/*********/
if (JFile::exists($file1) && JFile::exists($file2)) {
$diff = new jaDiffTool();
$objLeft = $diff->buildObject($title1, $file1, '', 0);
$objRight = $diff->buildObject($title2, $file2, '', 0);
$result = $diff->compare($objLeft, $objRight, 'file');
return $result;
} else {
return false;
}
}
/**
* display diff view for update.joomlart.com
*
* @param (string) $uniqueKey
* @param (string) $ver1
* @param (string) $ver2
* @return unknown
*/
function buildDiff2($uniqueKey, $version1, $version2)
{
$content["service"] = "buildDiff2";
$content["args"]["uniqueKey"] = $uniqueKey;
$content["args"]["version1"] = $version1;
$content["args"]["version2"] = $version2;
$result = $this->invokeService($this->buildMessage($content));
return $result;
}
/**
* with product get from local
*
* @param unknown_type $product
* @param unknown_type $logVersion
* @return unknown
*/
function getChangeLog($product, $logVersion)
{
if ($this->isLocalMode($product)) {
$changelog = $this->getChangeLogLocal($product, $logVersion);
if ($changelog !== false) {
return $changelog;
}
}
$pro = new jaProducts($product, $this->config);
$content["service"] = "getChangeLog";
$content["args"]["product"] = $pro->getInfo();
$content["args"]["logVersion"] = $logVersion;
$result = $this->invokeService($this->buildMessage($content), $product);
return $result;
}
/**
* @return same result with buildDiff but getting information from local repo
*/
function getChangeLogLocal($product, $logVersion)
{
if (!($productDir = $this->getLocalVersionsPath($product))) {
return false;
}
$logFile = $productDir . $logVersion."/change_log.log";
if (JFile::exists($logFile)) {
return file_get_contents($logFile);
} else {
return false;
}
}
/**
* with product get from server
*
* @param unknown_type $product
* @param unknown_type $logVersion
* @return unknown
*/
function getChangeLog2($product, $logVersion)
{
$content["service"] = "getChangeLog";
$content["args"]["product"] = $product;
$content["args"]["logVersion"] = $logVersion;
$result = $this->invokeService($this->buildMessage($content), $product);
return $result;
}
/**
* Do upgrade action
*/
function doUpgrade($product, $upgradeVersion)
{
$pro = new jaProducts($product, $this->config);
$upgradePackage = $this->_downloadUpgradePackage($pro, $upgradeVersion);
if ($upgradePackage === false) {
return false;
} else {
//check downloaded package
$json = json_decode(file_get_contents($upgradePackage));
if (is_object($json)) {
if (isset($json->content)) {
if (isset($json->content->error) && !empty($json->content->error)) {
jaucRaiseMessage($json->content->error, true);
return false;
}
}
jaucRaiseMessage("Upgrade Package is not valid format", true);
return false;
}
//
if ($pro->doUpgrade($upgradePackage, $upgradeVersion) === false) {
//throw new Exception('[UpdaterClient] Upgrade is fail', 100);
jaucRaiseMessage("Error occur when upgrading.", true);
return false;
}
return true;
}
}
function _downloadUpgradePackage($product, $upgradeVersion)
{
if ($this->isLocalMode($product)) {
return $this->_downloadUpgradePackageLocal($product, $upgradeVersion);
}
$content["service"] = "downloadUpgradePackage";
$content["args"]["product"] = $product->getFullInfo();
$content["args"]["newVersion"] = $upgradeVersion;
$message = "json=" . json_encode($this->buildMessage($content));
$tmpFile = jaTempnam(ja_sys_get_temp_dir(), 'ja');
$result =NetworkHelper::downloadFile($tmpFile, $this->getServiceUrl($product), $message);
$downloadedFile = $result["savePath"];
if (!JFile::exists($downloadedFile)) {
//throw new Exception('[UpdaterClient] Fail to download upgrade package', 100);
jaucRaiseMessage("Error occur when downloading upgrade package!", true);
return false;
} else {
@chmod($downloadedFile, 0644);
return $downloadedFile;
}
}
/**
* @return same result with _downloadUpgradePackage but getting information from local repo
*/
function _downloadUpgradePackageLocal($product, $upgradeVersion)
{
@set_time_limit(0);
$FileSystemHelper = new FileSystemHelper();
if ($product->version == $upgradeVersion) {
jaucRaiseMessage("UpdaterService: cannot upgrade to same version", true);
return false;
}
if (!($productDir = $this->getLocalVersionsPath($product))) {
return false;
}
//
$newVerDir = $productDir . $upgradeVersion.'/';
if (!JFolder::exists($newVerDir)) {
return false;
}
$vUpgrade = new stdClass();
$vUpgrade->crc = $this->getVersionChecksum($newVerDir);
//
$orgVerDir = $productDir . $product->version.'/';
if (JFolder::exists($orgVerDir)) {
$vServer = new stdClass();
$vServer->crc = $this->getVersionChecksum($orgVerDir);
}
//
$pro = new jaProducts($product, $this->config, true);
$oldPro = $pro->getFullInfo();
//
$pathPackageStore = $this->getLocalPatchPath($product);
$package = sprintf("%s_%s_%s.zip", $product->extKey, $product->version, $upgradeVersion);
$package = $pathPackageStore . $package;
if (!isset($vServer)) {
//clear cached package file
if (JFile::exists($package)) {
JFile::delete($package);
}
}
if (!JFile::exists($package)) {
$compare = new jaCompareTool();
if (isset($vServer)) {
$vResult = $compare->checkToBuildUpgradePackage($vServer, $vUpgrade);
} else {
$vResult = $compare->checkToBuildUpgradePackage($oldPro, $vUpgrade);
}
$tmpDir = $FileSystemHelper->tmpDir(null, 'ja', 0755);
$tmpDir = $tmpDir . $oldPro->extKey.'/';
if (JFolder::create($tmpDir, 0755) === false) {
jaucRaiseMessage("UpdaterService: cannot build upgrade package", true);
return false;
}
$infoFile = $tmpDir . "jaupdater.info.json";
JFile::write($infoFile, json_encode($vResult));
//echo $tmpDir;
$this->_buildUpgradePackage($newVerDir, $tmpDir, $vResult);
ArchiveHelper::zip($package, $tmpDir, true);
}
return $package;
}
function _buildUpgradePackage($src, $dst, $objectFilter)
{
$FileSystemHelper = new FileSystemHelper();
$src = $FileSystemHelper->clean($src);
$dst = $FileSystemHelper->clean($dst);
if (JFolder::exists($src)) {
if (!JFolder::exists($dst)) {
JFolder::create($dst, 0755);
}
$dir = opendir($src);
while (false !== ($file = readdir($dir))) {
if (($file != '.') && ($file != '..')) {
if (JFolder::exists($src.'/'.$file)) {
if (isset($objectFilter->$file)) {
$this->_buildUpgradePackage($src.'/'.$file, $dst.'/'.$file, $objectFilter->$file);
}
} else {
if (isset($objectFilter->$file) && in_array($objectFilter->$file, array('new', 'updated'))) {
JFile::copy($src.'/'.$file, $dst.'/'.$file);
}
}
}
}
closedir($dir);
} elseif (JFile::exists($src)) {
$file = basename($src);
if (JFolder::exists($dst)) {
$dst = $FileSystemHelper->clean($dst.'/'.$file);
}
if (isset($objectFilter->$file) && in_array($objectFilter->$file, array('new', 'updated'))) {
JFile::copy($src, $dst);
}
}
}
function _parseBackupInfo($fileInfo)
{
$aFields = array("extKey", "version", "createDate", "comment");
if (JFile::exists($fileInfo)) {
$content = file_get_contents($fileInfo);
preg_match_all("/([^\r\n=]+)=([^\r\n]*)/", $content, $matches);
$data = array();
foreach ($matches[1] as $key => $name) {
$data[$name] = $matches[2][$key];
}
foreach ($aFields as $key) {
if (!isset($data[$key])) {
$data[$key] = ""; //default value
}
}
return $data;
} else {
return false;
}
}
function listBackupFiles($product, $upgradeVersion)
{
$folder = $this->getLocalBackupPath($product);
$FileSystemHelper = new FileSystemHelper();
$files = $FileSystemHelper->files($folder);
if ($files) {
$aFiles = array();
$i = -1;
foreach ($files as $file) {
if ($FileSystemHelper->getExt($file) == "zip") {
if (strpos($file, $product->extKey) === 0) {
$backupName = $FileSystemHelper->stripExt($file);
$fileInfo = $folder . $backupName . ".txt";
if (($data = $this->_parseBackupInfo($fileInfo)) !== false) {
$i++;
$aFiles[$i]['extKey'] = $product->extKey;
$aFiles[$i]['version'] = $data["version"];
$aFiles[$i]['name'] = $file;
$aFiles[$i]['title'] = date("M d, Y - H:i:s", strtotime($data["createDate"]));
$aFiles[$i]['comment'] = $data["comment"];
if (JFolder::exists($folder . $backupName.'/')) {
$aFiles[$i]['conflicted'] = 1;
$aFiles[$i]['conflictedFolder'] = $backupName;
} else {
$aFiles[$i]['conflicted'] = 0;
}
}
}
}
}
if ($i >= 0) {
//sort by newer down to older
$aFiles = array_reverse($aFiles);
//group by version
return $this->msort($aFiles, 'version');
} else {
//throw new Exception('[UpdaterClient->listBackupFiles] No backup file is found', 100);
return false;
}
} else {
//throw new Exception('[UpdaterClient->listBackupFiles] No backup file is found', 100);
return false;
}
}
function listBackupConflicted($product, $version)
{
$backupDir = $this->getLocalConflictBasePath($product);
$aFolders = array();
$handle = opendir($backupDir);
$i = -1;
while (($entry = readdir($handle)) !== false) {
$path = $backupDir . $entry.'/';
if ($entry != '.' && $entry != '..' && JFolder::exists($path)) {
$i++;
$aFolders[$i] = array();
$aFolders[$i]['name'] = $entry;
$aFolders[$i]['title'] = date("M d, Y - H:i:s", $entry);
if (JFile::exists($path . "jaupdater.comment.txt")) {
$aFolders[$i]['comment'] = file_get_contents($path . "jaupdater.comment.txt");
}
}
}
closedir($handle);
if ($i >= 0) {
return $this->msort($aFolders, 'name');
} else {
return false;
}
}
function msort($array, $id = "id")
{
$temp_array = array();
while (count($array) > 0) {
$lowest_id = 0;
$index = 0;
foreach ($array as $item) {
if ($item[$id] > $array[$lowest_id][$id]) {
$lowest_id = $index;
}
$index++;
}
$temp_array[] = $array[$lowest_id];
$array = array_merge(array_slice($array, 0, $lowest_id), array_slice($array, $lowest_id + 1));
}
return $temp_array;
}
function doRecoveryFile($product, $file)
{
$folder = $this->getLocalBackupPath($product);
$pro = new jaProducts($product, $this->config);
$result = $pro->doRecovery($product, $folder, $file);
if ($result) {
return $result;
} else {
jaucRaiseMessage('Unsuccessfully Rollback', true);
//throw new Exception('[UpdaterClient->doRecoveryFile] Recovery is fail', 100);
return false;
}
}
/**
* LOCAL REPO METHODS
*/
/**
* method isNewerVersion
* @desc check if version 1 is newer than version 2
*
* @param string $ver1
* @param string $ver2
* @param boolean $equalIs
* @return
* 0 - if version 1 is older than version 2
* 1 - if version 1 is newer than version 2
* 2 - if can not detect status
*/
function isNewerVersion($ver1, $ver2, $equalIs = false)
{
if ($ver1 == $ver2) {
return ($equalIs) ? 1 : 0;
} else {
$aVer1 = explode('.', $ver1);
$aVer2 = explode('.', $ver2);
$cnt1 = count($aVer1);
$cnt2 = count($aVer2);
$cnt = max($cnt1, $cnt2);
$i = -1;
/*check what is newer version*/
$result = 1;
//first: set ver1 as newer version, ver2 as older version
while ($i < $cnt) {
$i++;
if (isset($aVer1[$i]) && isset($aVer2[$i])) {
if (intval($aVer1[$i]) < intval($aVer2[$i])) {
$result = 0;
break;
} elseif (intval($aVer1[$i]) > intval($aVer2[$i])) {
break;
}
if ($i == $cnt - 1) {
//two versions are the same
//but one of which is Beta or Alpha version
$result = 2;
}
} elseif (isset($aVer1[$i])) {
break;
} elseif (isset($aVer2[$i])) {
$result = 0;
break;
}
}
return $result;
}
}
function getVersionChecksum($path)
{
$cache = $path . "jaupdater.checksum.json";
if (JFile::exists($cache)) {
return file_get_contents($cache);
} else {
$md5CheckSums = new CheckSumsMD5();
$crc = $md5CheckSums->dumpCRCObject($path);
$json = json_encode($crc);
JFile::write($cache, $json);
return $json;
}
}
/**
* GET PATH OF PRODUCT ON LOCAL REPOSITORY
*/
function getLocalBasePath($product)
{
$basePath = JA_WORKING_DATA_FOLDER . $product->coreVersion.'/';
if ($product->type == 'plugin' && isset($product->group) && !empty($product->group)) {
$path = $basePath . $product->type.'/'.$product->group.'/'.$product->extKey.'/';
} else {
$path = $basePath . $product->type.'/'.$product->extKey.'/';
}
return $path;
}
function getLocalVersionsPath($product, $checkExists = true)
{
$path = $this->getLocalBasePath($product) . "versions/";
if (JFolder::exists($path) || !$checkExists) {
return $path;
} else {
return false;
}
}
function getLocalVersionPath($product, $checkExists = true)
{
$path = $this->getLocalVersionsPath($product, $checkExists) . $product->version.'/';
if (JFolder::exists($path) || !$checkExists) {
return $path;
} else {
return false;
}
}
function getLocalPatchPath($product)
{
$FileSystemHelper = new FileSystemHelper();
$path = $this->getLocalBasePath($product) . "patch/";
if (!JFolder::exists($path)) {
if (!$FileSystemHelper->createDirRecursive($path, 0755)) {
return false;
}
}
return $path;
}
function getLocalBackupPath($product)
{
$FileSystemHelper = new FileSystemHelper();
$path = $this->getLocalBasePath($product) . "backup/";
if (!JFolder::exists($path)) {
if (!$FileSystemHelper->createDirRecursive($path, 0755)) {
return false;
}
}
return $path;
}
function getLocalConflictPath($product, $folder = '')
{
$FileSystemHelper = new FileSystemHelper();
if ($folder == '') {
//create new folder to backup conflicted files
//$date = date("YmdHis");
$folder = time();
}
//store same folder with backup files
$path = $this->getLocalBasePath($product) . "backup/".$folder.'/';
if (!JFolder::exists($path)) {
if (!$FileSystemHelper->createDirRecursive($path, 0755)) {
return false;
}
}
return $path;
}
function getLocalConflictBasePath($product)
{
$FileSystemHelper = new FileSystemHelper();
$path = $this->getLocalBasePath($product) . "backup/";
if (!JFolder::exists($path)) {
if (!$FileSystemHelper->createDirRecursive($path, 0755)) {
return false;
}
}
return $path;
}
}
T1KUS90T