320 lines
8.7 KiB
PHP
320 lines
8.7 KiB
PHP
<?php
|
|
/**
|
|
* The model file of extension module of ZenTaoCMS.
|
|
*
|
|
* @copyright Copyright 2009-2011 QingDao Nature Easy Soft Network Technology Co,LTD (www.cnezsoft.com)
|
|
* @license LGPL (http://www.gnu.org/licenses/lgpl.html)
|
|
* @author Chunsheng Wang <chunsheng@cnezsoft.com>
|
|
* @package extension
|
|
* @version $Id$
|
|
* @link http://www.zentao.net
|
|
*/
|
|
class extensionModel extends model
|
|
{
|
|
/**
|
|
* The api agent(use snoopy).
|
|
*
|
|
* @var object
|
|
* @access public
|
|
*/
|
|
public $agent;
|
|
|
|
/**
|
|
* The api root.
|
|
*
|
|
* @var string
|
|
* @access public
|
|
*/
|
|
public $apiRoot;
|
|
|
|
/**
|
|
* The construct function.
|
|
*
|
|
* @access public
|
|
* @return void
|
|
*/
|
|
public function __construct()
|
|
{
|
|
parent::__construct();
|
|
$this->setAgent();
|
|
$this->setApiRoot();
|
|
}
|
|
|
|
/**
|
|
* Set the api agent.
|
|
*
|
|
* @access public
|
|
* @return void
|
|
*/
|
|
public function setAgent()
|
|
{
|
|
$this->agent = $this->app->loadClass('snoopy');
|
|
}
|
|
|
|
/**
|
|
* Set the apiRoot.
|
|
*
|
|
* @access public
|
|
* @return void
|
|
*/
|
|
public function setApiRoot()
|
|
{
|
|
$this->apiRoot = $this->config->extension->apiRoot;
|
|
}
|
|
|
|
/**
|
|
* Fetch data from an api.
|
|
*
|
|
* @param string $url
|
|
* @access public
|
|
* @return mixed
|
|
*/
|
|
public function fetchAPI($url)
|
|
{
|
|
$this->agent->fetch($url);
|
|
$result = json_decode($this->agent->results);
|
|
if(!isset($result->status)) return false;
|
|
if($result->status != 'success') return false;
|
|
if(isset($result->data) and md5($result->data) != $result->md5) return false;
|
|
if(isset($result->data)) return json_decode($result->data);
|
|
}
|
|
|
|
/**
|
|
* Get extension modules from the api.
|
|
*
|
|
* @access public
|
|
* @return void
|
|
*/
|
|
public function getModulesByAPI()
|
|
{
|
|
$requestType = $this->config->requestType;
|
|
$webRoot = helper::safe64Encode($this->config->webRoot);
|
|
$apiURL = $this->apiRoot . 'apiGetmodules-' . $requestType . '-' . $webRoot . '.json';
|
|
$data = $this->fetchAPI($apiURL);
|
|
if(isset($data->modules)) return $data->modules;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Get extensions by some condition.
|
|
*
|
|
* @param string $type
|
|
* @param mixe d $param
|
|
* @access public
|
|
* @return void
|
|
*/
|
|
public function getExtensionsByAPI($type, $param)
|
|
{
|
|
$apiURL = $this->apiRoot . 'apiGetExtensions-' . $type . '-' . $param . '.json';
|
|
$data = $this->fetchAPI($apiURL);
|
|
if(isset($data->extensions)) return $data;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Get the full path of the zip file of a extension.
|
|
*
|
|
* @param string $extension
|
|
* @access public
|
|
* @return string
|
|
*/
|
|
public function getPackageFile($extension)
|
|
{
|
|
return $this->app->getTmpRoot() . 'extension/' . $extension . '.zip';
|
|
}
|
|
|
|
/**
|
|
* Check the download path.
|
|
*
|
|
* @access public
|
|
* @return object the check result.
|
|
*/
|
|
public function checkDownloadPath()
|
|
{
|
|
/* Init the return. */
|
|
$return->result = 'ok';
|
|
$return->error = '';
|
|
|
|
$tmpRoot = $this->app->getTmpRoot();
|
|
$downloadPath = $tmpRoot . 'extension';
|
|
|
|
if(!is_dir($downloadPath))
|
|
{
|
|
if(is_writable($tmpRoot))
|
|
{
|
|
mkdir($downloadPath);
|
|
}
|
|
else
|
|
{
|
|
$return->result = 'fail';
|
|
$return->error = sprintf($this->lang->extension->errorDownloadPathNotFound, $downloadPath, $downloadPath);
|
|
}
|
|
}
|
|
elseif(!is_writable($downloadPath))
|
|
{
|
|
$return->result = 'fail';
|
|
$return->error = sprintf($this->lang->extension->errorDownloadPathNotWritable, $downloadPath, $downloadPath);
|
|
}
|
|
return $return;
|
|
}
|
|
|
|
/**
|
|
* Check extension files.
|
|
*
|
|
* @param string $extension
|
|
* @access public
|
|
* @return object
|
|
*/
|
|
public function checkExtensionPathes($extension)
|
|
{
|
|
$return->result = 'ok';
|
|
$return->errors = '';
|
|
$return->dirCommands = '';
|
|
$return->modCommands = '';
|
|
|
|
$appRoot = $this->app->getAppRoot();
|
|
$pathes = $this->extractPathesFromPackage($extension);
|
|
foreach($pathes as $path)
|
|
{
|
|
if($path == 'db' or $path == 'doc') continue;
|
|
$path = $appRoot . $path;
|
|
if(file_exists($path))
|
|
{
|
|
if(!is_writable($path))
|
|
{
|
|
$return->errors .= sprintf($this->lang->extension->errorTargetPathNotWritable, $path) . '<br />';
|
|
$return->modCommands .= "chmod -R 777 $path<br />";
|
|
}
|
|
}
|
|
elseif(!is_writable(dirname($path)))
|
|
{
|
|
$return->errors .= sprintf($this->lang->extension->errorTargetPathNotExists, $path) . '<br />';
|
|
$return->dirCommands .= "mkdir $path<br />";
|
|
$return->modCommands .= "chmod -R 777 $path<br />";
|
|
}
|
|
}
|
|
if($return->errors) $return->result = 'fail';
|
|
$return->dirCommands = str_replace('/', DIRECTORY_SEPARATOR, $return->dirCommands);
|
|
$return->errors .= $return->dirCommands . $return->modCommands;
|
|
return $return;
|
|
}
|
|
|
|
/**
|
|
* Download an extension.
|
|
*
|
|
* @param string $extension
|
|
* @param string $downLink
|
|
* @access public
|
|
* @return void
|
|
*/
|
|
public function downloadPackage($extension, $downLink)
|
|
{
|
|
$packageFile = $this->getPackageFile($extension);
|
|
$this->agent->fetch($downLink);
|
|
file_put_contents($packageFile, $this->agent->results);
|
|
}
|
|
|
|
/**
|
|
* Extract an extension.
|
|
*
|
|
* @param string $extension
|
|
* @access public
|
|
* @return void
|
|
*/
|
|
public function extractPackage($extension)
|
|
{
|
|
$packageFile = $this->getPackageFile($extension);
|
|
|
|
/* Extract the zip file. */
|
|
$this->app->loadClass('pclzip', true);
|
|
$zip = new pclzip($packageFile);
|
|
$zip->extract(PCLZIP_OPT_PATH, 'ext');
|
|
}
|
|
|
|
/**
|
|
* Extract pathes from an extension package.
|
|
*
|
|
* @param string $extension
|
|
* @access public
|
|
* @return array
|
|
*/
|
|
public function extractPathesFromPackage($extension)
|
|
{
|
|
$pathes = array();
|
|
$packageFile = $this->getPackageFile($extension);
|
|
|
|
/* Get files from the package file. */
|
|
$this->app->loadClass('pclzip', true);
|
|
$zip = new pclzip($packageFile);
|
|
$files = $zip->listContent();
|
|
|
|
foreach($files as $file)
|
|
{
|
|
$file = (object)$file;
|
|
if($file->folder) continue;
|
|
$file->filename = substr($file->filename, strpos($file->filename, '/') + 1);
|
|
$pathes[] = dirname($file->filename);
|
|
}
|
|
return array_unique($pathes);
|
|
}
|
|
|
|
/**
|
|
* Copy package files.
|
|
*
|
|
* @param int $extension
|
|
* @access public
|
|
* @return void
|
|
*/
|
|
public function copyPackageFiles($extension)
|
|
{
|
|
$this->xcopy("ext/$extension/module", $this->app->getAppRoot() . 'module');
|
|
$this->xcopy("ext/$extension/www", $this->app->getAppRoot() . 'www');
|
|
$this->xcopy("ext/$extension/bin", $this->app->getAppRoot() . 'bin');
|
|
$this->xcopy("ext/$extension/config", $this->app->getAppRoot() . 'config');
|
|
$this->xcopy("ext/$extension/lib", $this->app->getAppRoot() . 'bli');
|
|
}
|
|
|
|
/**
|
|
* Copy a directory from an directory to another directory.
|
|
*
|
|
* @param string $from
|
|
* @param string $to
|
|
* @access public
|
|
* @return array copied files.
|
|
*/
|
|
public function xcopy($from, $to)
|
|
{
|
|
static $copiedFiles = array();
|
|
|
|
if(!is_dir($from) or !is_readable($from)) return $copiedFiles;
|
|
if(!is_dir($to))
|
|
{
|
|
if(!is_writable(dirname($to))) return $copiedFiles;
|
|
mkdir($to);
|
|
}
|
|
|
|
$from = realpath($from) . '/';
|
|
$to = realpath($to) . '/';
|
|
$entries = scandir($from);
|
|
|
|
foreach($entries as $entry)
|
|
{
|
|
if($entry == '.' or $entry == '..') continue;
|
|
|
|
$fullEntry = $from . $entry;
|
|
if(is_file($fullEntry))
|
|
{
|
|
copy($fullEntry, $to . $entry);
|
|
$copiedFiles[] = $fullEntry;
|
|
}
|
|
else
|
|
{
|
|
$nextFrom = $from . $entry;
|
|
$nextTo = $to . $entry;
|
|
$this->xcopy($nextFrom, $nextTo);
|
|
}
|
|
}
|
|
return $copiedFiles;
|
|
}
|
|
}
|