function connect()
{
if (!$this->options['hostname'] || !$this->options['username'] || !$this->options['password']) {
if (!defined('SUPPORT_URL')) {
define('SUPPORT_URL', getOption('supportURL'));
}
appUpdateMsg('<a href="' . SUPPORT_URL . 'solution/articles/195233-asking-for-ftp-sftp-details-during-update/" target="_blank">See how to add the FTP details</a>.');
return false;
}
if (isset($this->options['ssl']) && $this->options['ssl'] && function_exists('ftp_ssl_connect')) {
$this->link = @ftp_ssl_connect($this->options['hostname'], $this->options['port'], FS_CONNECT_TIMEOUT);
} else {
$this->link = @ftp_connect($this->options['hostname'], $this->options['port'], FS_CONNECT_TIMEOUT);
}
if (!$this->link) {
//$this->errors->add('connect', sprintf(__('Failed to connect to FTP Server %1$s:%2$s'), $this->options['hostname'], $this->options['port']));
appUpdateMsg(sprintf('Failed to connect to the FTP server "%1$s:%2$s"', $this->options['hostname'], $this->options['port']));
return false;
}
if (!@ftp_login($this->link, $this->options['username'], $this->options['password'])) {
//$this->errors->add('auth', sprintf(__('Username/Password incorrect for %s'), $this->options['username']));
appUpdateMsg(sprintf('FTP username or password incorrect for "%s"', $this->options['username']));
return false;
}
//Set the Connection to use Passive FTP
if ($this->options['passive']) {
@ftp_pasv($this->link, true);
}
if (@ftp_get_option($this->link, FTP_TIMEOUT_SEC) < FS_TIMEOUT) {
@ftp_set_option($this->link, FTP_TIMEOUT_SEC, FS_TIMEOUT);
}
return true;
}
public function connect($host, $login, $password)
{
if (!parent::connect($host, $login, $password)) {
return false;
}
if (empty($this->port)) {
$this->port = 21;
}
$this->handle = $this->ssl && function_exists('ftp_ssl_connect') ? @ftp_ssl_connect($this->host, $this->port, $this->timeout) : @ftp_connect($this->host, $this->port, $this->timeout);
if ($this->handle && @ftp_login($this->handle, $this->login, $this->password)) {
@ftp_pasv($this->handle, true);
if (@ftp_get_option($this->handle, FTP_TIMEOUT_SEC) < $this->timeout) {
@ftp_set_option($this->handle, FTP_TIMEOUT_SEC, $this->timeout);
}
$this->connected = true;
return true;
}
return false;
}
public function connect()
{
if (isset($this->options['ssl']) && $this->options['ssl'] && function_exists('ftp_ssl_connect')) {
$this->link = @ftp_ssl_connect($this->options['hostname'], $this->options['port'], FS_CONNECT_TIMEOUT);
} else {
$this->link = @ftp_connect($this->options['hostname'], $this->options['port'], FS_CONNECT_TIMEOUT);
}
if (!$this->link) {
$this->errors->add('connect', sprintf(__('Failed to connect to FTP Server %1$s:%2$s'), $this->options['hostname'], $this->options['port']));
return false;
}
if (!@ftp_login($this->link, $this->options['username'], $this->options['password'])) {
$this->errors->add('auth', sprintf(__('Username/Password incorrect for %s'), $this->options['username']));
return false;
}
// Set the Connection to use Passive FTP
@ftp_pasv($this->link, true);
if (@ftp_get_option($this->link, FTP_TIMEOUT_SEC) < FS_TIMEOUT) {
@ftp_set_option($this->link, FTP_TIMEOUT_SEC, FS_TIMEOUT);
}
return true;
}
function connect()
{
if (isset($this->options['ssl']) && $this->options['ssl'] && function_exists('ftp_ssl_connect')) {
$this->link = @ftp_ssl_connect($this->options['hostname'], $this->options['port'], $this->options['connect_timeout']);
} else {
$this->link = @ftp_connect($this->options['hostname'], $this->options['port'], $this->options['connect_timeout']);
}
if (!$this->link) {
$this->errors->add('connect', sprintf('Could not connect to FTP server %s:%s', $this->options['hostname'], $this->options['port']));
return false;
}
if (!@ftp_login($this->link, $this->options['username'], $this->options['password'])) {
$this->errors->add('auth', 'The username and/or password is incorrect.');
return false;
}
//Set the Connection to use Passive FTP
@ftp_pasv($this->link, true);
if (@ftp_get_option($this->link, FTP_TIMEOUT_SEC) < $this->options['connection_timeout']) {
@ftp_set_option($this->link, FTP_TIMEOUT_SEC, $this->options['connection_timeout']);
}
return true;
}
/**
*
* 返回当前 FTP 连接的各种不同的选项设置
*
* @param int $option
* @return mixed
*/
public static function getOption($option)
{
return ftp_get_option(self::$resource, $option);
}
/**
* Determine if autoseek is enabled.
* Autoseek is used by the unobtrusive Upload/Download methods to automatically find the resume position.
*
* @return bool
*/
public function getAutoseek()
{
if (is_resource($this->cid)) {
return @ftp_get_option($this->cid, FTP_AUTOSEEK);
}
}
/**
* Evaluates the given variable
*
* @param mixed &$subject Variable to query
* @param bool $specialStr Should this be interpreted as a special string?
* @return mixed Result (both HTML and text modes generate strings)
*/
protected function evaluate(&$subject, $specialStr = false)
{
switch ($type = gettype($subject)) {
// https://github.com/digitalnature/php-ref/issues/13
case 'unknown type':
return $this->fmt->text('unknown');
// null value
// null value
case 'NULL':
return $this->fmt->text('null');
// integer/double/float
// integer/double/float
case 'integer':
case 'double':
return $this->fmt->text($type, $subject, $type);
// boolean
// boolean
case 'boolean':
$text = $subject ? 'true' : 'false';
return $this->fmt->text($text, $text, $type);
// arrays
// arrays
case 'array':
// empty array?
if (empty($subject)) {
$this->fmt->text('array');
return $this->fmt->emptyGroup();
}
if (isset($subject[static::MARKER_KEY])) {
unset($subject[static::MARKER_KEY]);
$this->fmt->text('array');
$this->fmt->emptyGroup('recursion');
return;
}
// first recursion level detection;
// this is optional (used to print consistent recursion info)
foreach ($subject as $key => &$value) {
if (!is_array($value)) {
continue;
}
// save current value in a temporary variable
$buffer = $value;
// assign new value
$value = $value !== 1 ? 1 : 2;
// if they're still equal, then we have a reference
if ($value === $subject) {
$value = $buffer;
$value[static::MARKER_KEY] = true;
$this->evaluate($value);
return;
}
// restoring original value
$value = $buffer;
}
$this->fmt->text('array');
$count = count($subject);
if (!$this->fmt->startGroup($count)) {
return;
}
$max = max(array_map('static::strLen', array_keys($subject)));
$subject[static::MARKER_KEY] = true;
foreach ($subject as $key => &$value) {
// ignore our temporary marker
if ($key === static::MARKER_KEY) {
continue;
}
if ($this->hasInstanceTimedOut()) {
break;
}
$keyInfo = gettype($key);
if ($keyInfo === 'string') {
$encoding = static::$env['mbStr'] ? mb_detect_encoding($key) : '';
$keyLen = $encoding && $encoding !== 'ASCII' ? static::strLen($key) . '; ' . $encoding : static::strLen($key);
$keyInfo = "{$keyInfo}({$keyLen})";
} else {
$keyLen = strlen($key);
}
$this->fmt->startRow();
$this->fmt->text('key', $key, "Key: {$keyInfo}");
$this->fmt->colDiv($max - $keyLen);
$this->fmt->sep('=>');
$this->fmt->colDiv();
$this->evaluate($value, $specialStr);
$this->fmt->endRow();
}
unset($subject[static::MARKER_KEY]);
$this->fmt->endGroup();
return;
// resource
// resource
case 'resource':
$meta = array();
$resType = get_resource_type($subject);
$this->fmt->text('resource', strval($subject));
if (!static::$config['showResourceInfo']) {
return $this->fmt->emptyGroup($resType);
}
// @see: http://php.net/manual/en/resource.php
// need to add more...
switch ($resType) {
// curl extension resource
case 'curl':
$meta = curl_getinfo($subject);
break;
case 'FTP Buffer':
$meta = array('time_out' => ftp_get_option($subject, FTP_TIMEOUT_SEC), 'auto_seek' => ftp_get_option($subject, FTP_AUTOSEEK));
break;
// gd image extension resource
// gd image extension resource
case 'gd':
$meta = array('size' => sprintf('%d x %d', imagesx($subject), imagesy($subject)), 'true_color' => imageistruecolor($subject));
break;
case 'ldap link':
$constants = get_defined_constants();
array_walk($constants, function ($value, $key) use(&$constants) {
if (strpos($key, 'LDAP_OPT_') !== 0) {
unset($constants[$key]);
}
});
// this seems to fail on my setup :(
unset($constants['LDAP_OPT_NETWORK_TIMEOUT']);
foreach (array_slice($constants, 3) as $key => $value) {
if (ldap_get_option($subject, (int) $value, $ret)) {
$meta[strtolower(substr($key, 9))] = $ret;
}
}
break;
// mysql connection (mysql extension is deprecated from php 5.4/5.5)
// mysql connection (mysql extension is deprecated from php 5.4/5.5)
case 'mysql link':
case 'mysql link persistent':
$dbs = array();
$query = @mysql_list_dbs($subject);
while ($row = @mysql_fetch_array($query)) {
$dbs[] = $row['Database'];
}
$meta = array('host' => ltrim(@mysql_get_host_info($subject), 'MySQL host info: '), 'server_version' => @mysql_get_server_info($subject), 'protocol_version' => @mysql_get_proto_info($subject), 'databases' => $dbs);
break;
// mysql result
// mysql result
case 'mysql result':
while ($row = @mysql_fetch_object($subject)) {
$meta[] = (array) $row;
if ($this->hasInstanceTimedOut()) {
break;
}
}
break;
// stream resource (fopen, fsockopen, popen, opendir etc)
// stream resource (fopen, fsockopen, popen, opendir etc)
case 'stream':
$meta = stream_get_meta_data($subject);
break;
}
if (!$meta) {
return $this->fmt->emptyGroup($resType);
}
if (!$this->fmt->startGroup($resType)) {
return;
}
$max = max(array_map('static::strLen', array_keys($meta)));
foreach ($meta as $key => $value) {
$this->fmt->startRow();
$this->fmt->text('resourceProp', ucwords(str_replace('_', ' ', $key)));
$this->fmt->colDiv($max - static::strLen($key));
$this->fmt->sep(':');
$this->fmt->colDiv();
$this->evaluate($value);
$this->fmt->endRow();
}
$this->fmt->endGroup();
return;
// string
// string
case 'string':
$length = static::strLen($subject);
$encoding = static::$env['mbStr'] ? mb_detect_encoding($subject) : false;
$info = $encoding && $encoding !== 'ASCII' ? $length . '; ' . $encoding : $length;
if ($specialStr) {
$this->fmt->sep('"');
$this->fmt->text(array('string', 'special'), $subject, "string({$info})");
$this->fmt->sep('"');
return;
}
$this->fmt->text('string', $subject, "string({$info})");
// advanced checks only if there are 3 characteres or more
if (static::$config['showStringMatches'] && $length > 2 && trim($subject) !== '') {
$isNumeric = is_numeric($subject);
// very simple check to determine if the string could match a file path
// @note: this part of the code is very expensive
$isFile = $length < 2048 && max(array_map('strlen', explode('/', str_replace('\\', '/', $subject)))) < 128 && !preg_match('/[^\\w\\.\\-\\/\\\\:]|\\..*\\.|\\.$|:(?!(?<=^[a-zA-Z]:)[\\/\\\\])/', $subject);
if ($isFile) {
try {
$file = new \SplFileInfo($subject);
$flags = array();
$perms = $file->getPerms();
if (($perms & 0xc000) === 0xc000) {
// socket
$flags[] = 's';
} elseif (($perms & 0xa000) === 0xa000) {
// symlink
$flags[] = 'l';
} elseif (($perms & 0x8000) === 0x8000) {
// regular
$flags[] = '-';
} elseif (($perms & 0x6000) === 0x6000) {
// block special
$flags[] = 'b';
} elseif (($perms & 0x4000) === 0x4000) {
// directory
$flags[] = 'd';
} elseif (($perms & 0x2000) === 0x2000) {
// character special
$flags[] = 'c';
} elseif (($perms & 0x1000) === 0x1000) {
// FIFO pipe
$flags[] = 'p';
} else {
// unknown
$flags[] = 'u';
}
// owner
$flags[] = $perms & 0x100 ? 'r' : '-';
$flags[] = $perms & 0x80 ? 'w' : '-';
$flags[] = $perms & 0x40 ? $perms & 0x800 ? 's' : 'x' : ($perms & 0x800 ? 'S' : '-');
// group
$flags[] = $perms & 0x20 ? 'r' : '-';
$flags[] = $perms & 0x10 ? 'w' : '-';
$flags[] = $perms & 0x8 ? $perms & 0x400 ? 's' : 'x' : ($perms & 0x400 ? 'S' : '-');
// world
$flags[] = $perms & 0x4 ? 'r' : '-';
$flags[] = $perms & 0x2 ? 'w' : '-';
$flags[] = $perms & 0x1 ? $perms & 0x200 ? 't' : 'x' : ($perms & 0x200 ? 'T' : '-');
$size = is_dir($subject) ? '' : sprintf(' %.2fK', $file->getSize() / 1024);
$this->fmt->startContain('file', true);
$this->fmt->text('file', implode('', $flags) . $size);
$this->fmt->endContain();
} catch (\Exception $e) {
$isFile = false;
}
}
// class/interface/function
if (!preg_match('/[^\\w+\\\\]/', $subject) && $length < 96) {
$isClass = class_exists($subject, false);
if ($isClass) {
$this->fmt->startContain('class', true);
$this->fromReflector(new \ReflectionClass($subject));
$this->fmt->endContain();
}
if (!$isClass && interface_exists($subject, false)) {
$this->fmt->startContain('interface', true);
$this->fromReflector(new \ReflectionClass($subject));
$this->fmt->endContain('interface');
}
if (function_exists($subject)) {
$this->fmt->startContain('function', true);
$this->fromReflector(new \ReflectionFunction($subject));
$this->fmt->endContain('function');
}
}
// skip serialization/json/date checks if the string appears to be numeric,
// or if it's shorter than 5 characters
if (!$isNumeric && $length > 4) {
// url
if (static::$config['showUrls'] && static::$env['curlActive'] && filter_var($subject, FILTER_VALIDATE_URL)) {
$ch = curl_init($subject);
curl_setopt($ch, CURLOPT_NOBODY, true);
curl_exec($ch);
$nfo = curl_getinfo($ch);
curl_close($ch);
if ($nfo['http_code']) {
$this->fmt->startContain('url', true);
$contentType = explode(';', $nfo['content_type']);
$this->fmt->text('url', sprintf('%s:%d %s %.2fms (%d)', !empty($nfo['primary_ip']) ? $nfo['primary_ip'] : null, !empty($nfo['primary_port']) ? $nfo['primary_port'] : null, $contentType[0], $nfo['total_time'], $nfo['http_code']));
$this->fmt->endContain();
}
}
// date
if ($length < 128 && static::$env['supportsDate'] && !preg_match('/[^A-Za-z0-9.:+\\s\\-\\/]/', $subject)) {
try {
$date = new \DateTime($subject);
$errors = \DateTime::getLastErrors();
if ($errors['warning_count'] < 1 && $errors['error_count'] < 1) {
$now = new \Datetime('now');
$nowUtc = new \Datetime('now', new \DateTimeZone('UTC'));
$diff = $now->diff($date);
$map = array('y' => 'yr', 'm' => 'mo', 'd' => 'da', 'h' => 'hr', 'i' => 'min', 's' => 'sec');
$timeAgo = 'now';
foreach ($map as $k => $label) {
if ($diff->{$k} > 0) {
$timeAgo = $diff->format("%R%{$k}{$label}");
break;
}
}
$tz = $date->getTimezone();
$offs = round($tz->getOffset($nowUtc) / 3600);
if ($offs > 0) {
$offs = "+{$offs}";
}
$timeAgo .= (int) $offs !== 0 ? ' ' . sprintf('%s (UTC%s)', $tz->getName(), $offs) : ' UTC';
$this->fmt->startContain('date', true);
$this->fmt->text('date', $timeAgo);
$this->fmt->endContain();
}
} catch (\Exception $e) {
// not a date
}
}
// attempt to detect if this is a serialized string
static $unserializing = 0;
$isSerialized = $unserializing < 3 && ($subject[$length - 1] === ';' || $subject[$length - 1] === '}') && in_array($subject[0], array('s', 'a', 'O'), true) && ($subject[0] === 's' && $subject[$length - 2] !== '"' || preg_match("/^{$subject[0]}:[0-9]+:/s", $subject)) && ($unserialized = @unserialize($subject)) !== false;
if ($isSerialized) {
$unserializing++;
$this->fmt->startContain('serialized', true);
$this->evaluate($unserialized);
$this->fmt->endContain();
$unserializing--;
}
// try to find out if it's a json-encoded string;
// only do this for json-encoded arrays or objects, because other types have too generic formats
static $decodingJson = 0;
$isJson = !$isSerialized && $decodingJson < 3 && in_array($subject[0], array('{', '['), true);
if ($isJson) {
$decodingJson++;
$json = json_decode($subject);
if ($isJson = json_last_error() === JSON_ERROR_NONE) {
$this->fmt->startContain('json', true);
$this->evaluate($json);
$this->fmt->endContain();
}
$decodingJson--;
}
// attempt to match a regex
if ($length < 768) {
try {
$components = $this->splitRegex($subject);
if ($components) {
$regex = '';
$this->fmt->startContain('regex', true);
foreach ($components as $component) {
$this->fmt->text('regex-' . key($component), reset($component));
}
$this->fmt->endContain();
}
} catch (\Exception $e) {
// not a regex
}
}
}
}
return;
}
// if we reached this point, $subject must be an object
// track objects to detect recursion
static $hashes = array();
// hash ID of this object
$hash = spl_object_hash($subject);
$recursion = isset($hashes[$hash]);
// sometimes incomplete objects may be created from string unserialization,
// if the class to which the object belongs wasn't included until the unserialization stage...
if ($subject instanceof \__PHP_Incomplete_Class) {
$this->fmt->text('object');
$this->fmt->emptyGroup('incomplete');
return;
}
// check cache at this point
if (!$recursion && $this->fmt->didCache($hash)) {
static::$debug['cacheHits']++;
return;
}
$reflector = new \ReflectionObject($subject);
$this->fmt->startContain('class');
$this->fromReflector($reflector);
$this->fmt->text('object', ' object');
$this->fmt->endContain();
// already been here?
if ($recursion) {
return $this->fmt->emptyGroup('recursion');
}
$hashes[$hash] = 1;
$flags = \ReflectionProperty::IS_PUBLIC | \ReflectionProperty::IS_PROTECTED;
if (static::$config['showPrivateMembers']) {
$flags |= \ReflectionProperty::IS_PRIVATE;
}
$props = $reflector->getProperties($flags);
$methods = array();
if (static::$config['showMethods']) {
$flags = \ReflectionMethod::IS_PUBLIC | \ReflectionMethod::IS_PROTECTED;
if (static::$config['showPrivateMembers']) {
$flags |= \ReflectionMethod::IS_PRIVATE;
}
$methods = $reflector->getMethods($flags);
}
$constants = $reflector->getConstants();
$interfaces = $reflector->getInterfaces();
$traits = static::$env['is54'] ? $reflector->getTraits() : array();
$parents = static::getParentClasses($reflector);
// work-around for https://bugs.php.net/bug.php?id=49154
// @see http://stackoverflow.com/questions/15672287/strange-behavior-of-reflectiongetproperties-with-numeric-keys
if (!static::$env['is54']) {
$props = array_values(array_filter($props, function ($prop) use($subject) {
return !$prop->isPublic() || property_exists($subject, $prop->name);
}));
}
// no data to display?
if (!$props && !$methods && !$constants && !$interfaces && !$traits) {
unset($hashes[$hash]);
return $this->fmt->emptyGroup();
}
if (!$this->fmt->startGroup()) {
return;
}
// show contents for iterators
if (static::$config['showIteratorContents'] && $reflector->isIterateable()) {
$itContents = iterator_to_array($subject);
$this->fmt->sectionTitle(sprintf('Contents (%d)', count($itContents)));
foreach ($itContents as $key => $value) {
$keyInfo = gettype($key);
if ($keyInfo === 'string') {
$encoding = static::$env['mbStr'] ? mb_detect_encoding($key) : '';
$length = $encoding && $encoding !== 'ASCII' ? static::strLen($key) . '; ' . $encoding : static::strLen($key);
$keyInfo = sprintf('%s(%s)', $keyInfo, $length);
}
$this->fmt->startRow();
$this->fmt->text(array('key', 'iterator'), $key, sprintf('Iterator key: %s', $keyInfo));
$this->fmt->colDiv();
$this->fmt->sep('=>');
$this->fmt->colDiv();
$this->evaluate($value);
//$this->evaluate($value instanceof \Traversable ? ((count($value) > 0) ? $value : (string)$value) : $value);
$this->fmt->endRow();
}
}
// display the interfaces this objects' class implements
if ($interfaces) {
$items = array();
$this->fmt->sectionTitle('Implements');
$this->fmt->startRow();
$this->fmt->startContain('interfaces');
$i = 0;
$count = count($interfaces);
foreach ($interfaces as $name => $interface) {
$this->fromReflector($interface);
if (++$i < $count) {
$this->fmt->sep(', ');
}
}
$this->fmt->endContain();
$this->fmt->endRow();
}
// traits this objects' class uses
if ($traits) {
$items = array();
$this->fmt->sectionTitle('Uses');
$this->fmt->startRow();
$this->fmt->startContain('traits');
$i = 0;
$count = count($traits);
foreach ($traits as $name => $trait) {
$this->fromReflector($trait);
if (++$i < $count) {
$this->fmt->sep(', ');
}
}
$this->fmt->endContain();
$this->fmt->endRow();
}
// class constants
if ($constants) {
$this->fmt->sectionTitle('Constants');
$max = max(array_map('static::strLen', array_keys($constants)));
foreach ($constants as $name => $value) {
$meta = null;
$type = array('const');
foreach ($parents as $parent) {
if ($parent->hasConstant($name)) {
if ($parent !== $reflector) {
$type[] = 'inherited';
$meta = array('sub' => array(array('Prototype defined by', $parent->name)));
}
break;
}
}
$this->fmt->startRow();
$this->fmt->sep('::');
$this->fmt->colDiv();
$this->fmt->startContain($type);
$this->fmt->text('name', $name, $meta, $this->linkify($parent, $name));
$this->fmt->endContain();
$this->fmt->colDiv($max - static::strLen($name));
$this->fmt->sep('=');
$this->fmt->colDiv();
$this->evaluate($value);
$this->fmt->endRow();
}
}
// object/class properties
if ($props) {
$this->fmt->sectionTitle('Properties');
$max = 0;
foreach ($props as $idx => $prop) {
if (($propNameLen = static::strLen($prop->name)) > $max) {
$max = $propNameLen;
}
}
foreach ($props as $idx => $prop) {
if ($this->hasInstanceTimedOut()) {
break;
}
$bubbles = array();
$sourceClass = $prop->getDeclaringClass();
$inherited = $reflector->getShortName() !== $sourceClass->getShortName();
$meta = $sourceClass->isInternal() ? null : static::parseComment($prop->getDocComment());
if ($meta) {
if ($inherited) {
$meta['sub'] = array(array('Declared in', $sourceClass->getShortName()));
}
if (isset($meta['tags']['var'][0])) {
$meta['left'] = $meta['tags']['var'][0][0];
}
unset($meta['tags']);
}
if ($prop->isProtected() || $prop->isPrivate()) {
$prop->setAccessible(true);
}
$value = $prop->getValue($subject);
$this->fmt->startRow();
$this->fmt->sep($prop->isStatic() ? '::' : '->');
$this->fmt->colDiv();
$bubbles = array();
if ($prop->isProtected()) {
$bubbles[] = array('P', 'Protected');
}
if ($prop->isPrivate()) {
$bubbles[] = array('!', 'Private');
}
$this->fmt->bubbles($bubbles);
$type = array('prop');
if ($inherited) {
$type[] = 'inherited';
}
if ($prop->isPrivate()) {
$type[] = 'private';
}
$this->fmt->colDiv(2 - count($bubbles));
$this->fmt->startContain($type);
$this->fmt->text('name', $prop->name, $meta, $this->linkify($prop));
$this->fmt->endContain();
$this->fmt->colDiv($max - static::strLen($prop->name));
$this->fmt->sep('=');
$this->fmt->colDiv();
$this->evaluate($value);
$this->fmt->endRow();
}
}
// class methods
if ($methods && !$this->hasInstanceTimedOut()) {
$this->fmt->sectionTitle('Methods');
foreach ($methods as $idx => $method) {
$this->fmt->startRow();
$this->fmt->sep($method->isStatic() ? '::' : '->');
$this->fmt->colDiv();
$bubbles = array();
if ($method->isAbstract()) {
$bubbles[] = array('A', 'Abstract');
}
if ($method->isFinal()) {
$bubbles[] = array('F', 'Final');
}
if ($method->isProtected()) {
$bubbles[] = array('P', 'Protected');
}
if ($method->isPrivate()) {
$bubbles[] = array('!', 'Private');
}
$this->fmt->bubbles($bubbles);
$this->fmt->colDiv(4 - count($bubbles));
// is this method inherited?
$inherited = $reflector->getShortName() !== $method->getDeclaringClass()->getShortName();
$type = array('method');
if ($inherited) {
$type[] = 'inherited';
}
if ($method->isPrivate()) {
$type[] = 'private';
}
$this->fmt->startContain($type);
$name = $method->name;
if ($method->returnsReference()) {
$name = "&{$name}";
}
$this->fromReflector($method, $name, $reflector);
$paramCom = $method->isInternal() ? array() : static::parseComment($method->getDocComment(), 'tags');
$paramCom = empty($paramCom['param']) ? array() : $paramCom['param'];
$paramCount = $method->getNumberOfParameters();
$this->fmt->sep('(');
// process arguments
foreach ($method->getParameters() as $idx => $parameter) {
$meta = null;
$paramName = "\${$parameter->name}";
$optional = $parameter->isOptional();
$variadic = static::$env['is56'] && $parameter->isVariadic();
if ($parameter->isPassedByReference()) {
$paramName = "&{$paramName}";
}
if ($variadic) {
$paramName = "...{$paramName}";
}
$type = array('param');
if ($optional) {
$type[] = 'optional';
}
$this->fmt->startContain($type);
// attempt to build meta
foreach ($paramCom as $tag) {
list($pcTypes, $pcName, $pcDescription) = $tag;
if ($pcName !== $paramName) {
continue;
}
$meta = array('title' => $pcDescription);
if ($pcTypes) {
$meta['left'] = $pcTypes;
}
break;
}
try {
$paramClass = $parameter->getClass();
} catch (\Exception $e) {
// @see https://bugs.php.net/bug.php?id=32177&edit=1
}
if (!empty($paramClass)) {
$this->fmt->startContain('hint');
$this->fromReflector($paramClass, $paramClass->name);
$this->fmt->endContain();
$this->fmt->sep(' ');
}
if ($parameter->isArray()) {
$this->fmt->text('hint', 'array');
$this->fmt->sep(' ');
}
$this->fmt->text('name', $paramName, $meta);
if ($optional) {
$paramValue = $parameter->isDefaultValueAvailable() ? $parameter->getDefaultValue() : null;
$this->fmt->sep(' = ');
if (static::$env['is546'] && !$parameter->getDeclaringFunction()->isInternal() && $parameter->isDefaultValueConstant()) {
$this->fmt->text('constant', $parameter->getDefaultValueConstantName(), 'Constant');
} else {
$this->evaluate($paramValue, true);
}
}
$this->fmt->endContain();
if ($idx < $paramCount - 1) {
$this->fmt->sep(', ');
}
}
$this->fmt->sep(')');
$this->fmt->endContain();
$this->fmt->endRow();
}
}
unset($hashes[$hash]);
$this->fmt->endGroup();
$this->fmt->cacheLock($hash);
}
/**
* Get the currently set timeout.
* Returns the actual timeout set.
*
* @access public
* @return int The actual timeout
*/
function getTimeout()
{
return ftp_get_option($this->_handle, FTP_TIMEOUT_SEC);
}
/**
* Lance le téléchargement du fichier par FTP sur le serveur
* @param $directory_file
* @param $server_file
* @return bool
*/
public function getRemoteFile($directory_file, $server_file)
{
$timeout = ftp_get_option($this->ftpConnect(), FTP_TIMEOUT_SEC);
// try to download server_file and save to local_file
if (ftp_get($this->ftpConnect(), $directory_file, $server_file, FTP_BINARY)) {
return true;
} else {
return false;
}
ftp_close($this->ftpConnect());
}
/**
* Retrieves various runtime behaviour of the current stream
* @link http://php.net/ftp_get_option
*
* @param integer $option Runtime option. (FTPWrapper::TIMEOUT_SEC, FTPWrapper::AUTOSEEK)
* @return mixed Value on success, FALSE on error
*/
public function getOption($option)
{
return ftp_get_option($this->connection->getStream(), $option);
}
function woo_ce_cron_export( $gui = '', $type = '', $is_scheduled = false ) {
global $export;
$export = new stdClass;
$export->cron = ( $is_scheduled ? 0 : 1 );
$export->scheduled_export = ( $is_scheduled ? 1 : 0 );
$export->start_time = time();
$export->idle_memory_start = woo_ce_current_memory_usage();
$export->error = '';
$bits = '';
$type = ( isset( $_GET['type'] ) ? $_GET['type'] : $type );
if( empty( $type ) ) {
if( $gui == 'gui' ) {
$output = sprintf( '<p>%s</p>', __( 'No export type was provided.', 'woo_ce' ) );
} else {
error_log( sprintf( '[store-exporter-deluxe] -: Error: %s', __( 'No export type was provided', 'woo_ce' ) ) );
return false;
}
} else {
$types = array_keys( woo_ce_return_export_types() );
$export->type = $type;
// Check that export is in the list of available exports
if( !in_array( $export->type, $types ) ) {
if( $gui == 'gui' ) {
$output = '<p>' . __( 'An invalid export type was provided.', 'woo_ce' ) . '</p>';
} else {
error_log( sprintf( '[store-exporter-deluxe] -: Error: %s', __( 'An invalid export type was provided', 'woo_ce' ) ) );
return false;
}
} else {
$export->export_format = ( isset( $_GET['format'] ) ? sanitize_text_field( $_GET['format'] ) : woo_ce_get_option( 'export_format', 'csv' ) );
// Override the export format if outputting to screen in friendly design
if( $gui == 'gui' && in_array( $export->export_format, array( 'csv', 'xls', 'xlsx' ) ) )
$export->export_format = 'csv';
// Override the export format if this is a scheduled export
if( $export->scheduled_export )
$export->export_format = woo_ce_get_option( 'auto_format', 'csv' );
// Override the export format if the single order Transient is set
$single_export_format = get_transient( WOO_CD_PREFIX . '_single_export_format' );
if( $single_export_format !== false )
$export->export_format = $single_export_format;
unset( $single_export_format );
$export->delimiter = ( isset( $_GET['delimiter'] ) ? sanitize_text_field( $_GET['delimiter'] ) : woo_ce_get_option( 'delimiter', ',' ) );
if( $export->delimiter == '' || $export->delimiter == false ) {
error_log( '[store-exporter-deluxe] Warning: Delimiter export option was corrupted, defaulted to ,' );
$export->delimiter = ',';
woo_ce_update_option( 'delimiter', ',' );
} else if( $export->delimiter == 'TAB' ) {
$export->delimiter = "\t";
}
$export->category_separator = ( isset( $_GET['category_separator'] ) ? sanitize_text_field( $_GET['category_separator'] ) : woo_ce_get_option( 'category_separator', '|' ) );
// Override for line break (LF) support in Category Separator
if( $export->category_separator == 'LF' )
$export->category_separator = "\n";
$export->bom = ( isset( $_GET['bom'] ) ? absint( $_GET['bom'] ) : woo_ce_get_option( 'bom', 1 ) );
$export->encoding = ( isset( $_GET['encoding'] ) ? sanitize_text_field( $_GET['encoding'] ) : woo_ce_get_option( 'encoding', 'UTF-8' ) );
$export->timeout = woo_ce_get_option( 'timeout', 600 );
$export->escape_formatting = ( isset( $_GET['escape_formatting'] ) ? sanitize_text_field( $_GET['escape_formatting'] ) : woo_ce_get_option( 'escape_formatting', 'all' ) );
$export->header_formatting = ( isset( $_GET['header_formatting'] ) ? absint( $_GET['header_formatting'] ) : woo_ce_get_option( 'header_formatting', 1 ) );
$export->date_format = woo_ce_get_option( 'date_format', 'd/m/Y' );
$export->order_items = ( isset( $_GET['order_items'] ) ? sanitize_text_field( $_GET['order_items'] ) : woo_ce_get_option( 'order_items_formatting', 'unique' ) );
$export->order_items_types = ( isset( $_GET['order_items_types'] ) ? sanitize_text_field( $_GET['order_items_types'] ) : woo_ce_get_option( 'order_items_types', false ) );
$export->upsell_formatting = woo_ce_get_option( 'upsell_formatting', 1 );
$export->crosssell_formatting = woo_ce_get_option( 'crosssell_formatting', 1 );
$export->gallery_formatting = woo_ce_get_option( 'gallery_formatting', 0 );
$export->gallery_unique = woo_ce_get_option( 'gallery_unique', 0 );
$export->max_product_gallery = woo_ce_get_option( 'max_product_gallery', 3 );
$export->filename = woo_ce_generate_filename( $export->type );
switch( $export->export_format ) {
case 'csv':
$php_excel_format = 'SED_CSV';
$file_extension = 'csv';
$post_mime_type = 'text/csv';
break;
case 'xls':
$php_excel_format = 'Excel5';
$file_extension = 'xls';
$post_mime_type = 'application/vnd.ms-excel';
break;
case 'xlsx':
$php_excel_format = 'Excel2007';
$file_extension = 'xlsx';
$post_mime_type = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
break;
case 'xml':
$file_extension = 'xml';
$post_mime_type = 'application/xml';
break;
case 'rss':
$file_extension = 'xml';
$post_mime_type = 'application/rss+xml';
break;
default:
error_log( sprintf( '[store-exporter-deluxe] -: Warning: %s', __( 'An invalid export format was provided', 'woo_ce' ) ) );
return;
break;
}
$export->filename = $export->filename . '.' . $file_extension;
$export->limit_volume = ( isset( $_GET['limit'] ) ? absint( $_GET['limit'] ) : -1 );
$export->offset = ( isset( $_GET['offset'] ) ? absint( $_GET['offset'] ) : 0 );
// Select all export fields for CRON export
$export->fields = woo_ce_cron_export_fields( $export->type, $export->scheduled_export );
// Grab to value if response is e-mail or remote POST
if( in_array( $gui, array( 'email', 'post' ) ) ) {
if( $gui == 'email' )
$export->to = ( isset( $_GET['to'] ) ? sanitize_email( $_GET['to'] ) : woo_ce_get_option( 'email_to', '' ) );
else if( $gui == 'post' )
$export->to = ( isset( $_GET['to'] ) ? esc_url_raw( $_GET['to'] ) : woo_ce_get_option( 'post_to', '' ) );
}
$export = woo_ce_check_cron_export_arguments( $export );
$export->args = array(
'limit_volume' => $export->limit_volume,
'offset' => $export->offset,
'encoding' => $export->encoding,
'date_format' => $export->date_format,
'order_items' => $export->order_items,
'order_items_types' => $export->order_items_types
);
$orderby = ( isset( $_GET['orderby'] ) ? sanitize_text_field( $_GET['orderby'] ) : null );
$order = ( isset( $_GET['order'] ) ? sanitize_text_field( $_GET['order'] ) : null );
switch( $export->type ) {
case 'product':
$export->args['product_orderby'] = $orderby;
$export->args['product_order'] = $order;
if( $export->scheduled_export ) {
$product_filter_type = woo_ce_get_option( 'auto_product_type', false );
$product_filter_status = woo_ce_get_option( 'auto_product_status', false );
$product_filter_stock = woo_ce_get_option( 'auto_product_stock', false );
$product_filter_category = woo_ce_get_option( 'auto_product_category', false );
$product_filter_tag = woo_ce_get_option( 'auto_product_tag', false );
$export->args['product_type'] = ( !empty( $product_filter_type ) ? $product_filter_type : false );
$export->args['product_status'] = ( !empty( $product_filter_status ) ? $product_filter_status : false );
$export->args['product_stock'] = ( !empty( $product_filter_stock ) ? $product_filter_stock : false );
$export->args['product_categories'] = ( !empty( $product_filter_category ) ? $product_filter_category : false );
$export->args['product_tags'] = ( !empty( $product_filter_tag ) ? $product_filter_tag : false );
} else {
$export->args['product_status'] = ( isset( $_GET['product_status'] ) ? sanitize_text_field( $_GET['product_status'] ) : null );
$export->args['product_stock'] = ( isset( $_GET['stock_status'] ) ? sanitize_text_field( $_GET['stock_status'] ) : null );
}
break;
case 'category':
$export->args['category_orderby'] = $orderby;
$export->args['category_order'] = $order;
break;
case 'tag':
$export->args['tag_orderby'] = $orderby;
$export->args['tag_order'] = $order;
break;
case 'order':
$export->args['order_orderby'] = $orderby;
$export->args['order_order'] = $order;
$export->args['order_ids'] = ( isset( $_GET['order_ids'] ) ? sanitize_text_field( $_GET['order_ids'] ) : null );
// Override Filter Orders by Order ID if a single order transient is set
$single_export_order_ids = get_transient( WOO_CD_PREFIX . '_single_export_order_ids' );
if( $single_export_order_ids !== false )
$export->args['order_ids'] = sanitize_text_field( $single_export_order_ids );
unset( $single_export_order_ids );
if( $export->scheduled_export ) {
// Scheduled export engine
// Order Status
$order_filter_status = woo_ce_get_option( 'auto_order_status', '' );
$export->args['order_status'] = ( !empty( $order_filter_status ) ? (array)$order_filter_status : array() );
// Order Date
$order_dates_filter = woo_ce_get_option( 'auto_order_date', false );
if( $order_dates_filter ) {
$export->args['order_dates_filter'] = $order_dates_filter;
switch( $order_dates_filter ) {
case 'manual':
$order_filter_dates_from = woo_ce_get_option( 'auto_order_dates_from', false );
$order_filter_dates_to = woo_ce_get_option( 'auto_order_dates_to', false );
$export->args['order_dates_from'] = ( !empty( $order_filter_dates_from ) ? sanitize_text_field( $order_filter_dates_from ) : false );
$export->args['order_dates_to'] = ( !empty( $order_filter_dates_to ) ? sanitize_text_field( $order_filter_dates_to ) : false );
break;
case 'variable':
$order_filter_date_variable = woo_ce_get_option( 'auto_order_date_variable', false );
$order_filter_date_variable_length = woo_ce_get_option( 'auto_order_date_variable_length', false );
$export->args['order_dates_filter_variable'] = ( !empty( $order_filter_date_variable ) ? absint( $order_filter_date_variable ) : false );
$export->args['order_dates_filter_variable_length'] = ( !empty( $order_filter_date_variable_length ) ? sanitize_text_field( $order_filter_date_variable_length ) : false );
break;
}
}
// Product
$order_filter_product = woo_ce_get_option( 'auto_order_product', '' );
$export->args['order_product'] = ( !empty( $order_filter_product ) ? (array)$order_filter_product : array() );
// Billing Country
$order_filter_billing_country = woo_ce_get_option( 'auto_order_billing_country', false );
$export->args['order_billing_country'] = ( !empty( $order_filter_billing_country ) ? array_map( 'sanitize_text_field', $order_filter_billing_country ) : false );
// Shipping Country
$order_filter_shipping_country = woo_ce_get_option( 'auto_order_shipping_country', false );
$export->args['order_shipping_country'] = ( !empty( $order_filter_shipping_country ) ? array_map( 'sanitize_text_field', $order_filter_shipping_country ) : false );
// Payment Gateway
$order_filter_payment = woo_ce_get_option( 'auto_order_payment', array() );
$export->args['order_payment'] = ( !empty( $order_filter_payment ) ? array_map( 'sanitize_text_field', $order_filter_payment ) : false );
// Shipping Method
$order_filter_shipping = woo_ce_get_option( 'auto_order_shipping', array() );
$export->args['order_shipping'] = ( !empty( $order_filter_shipping ) ? array_map( 'sanitize_text_field', $order_filter_shipping ) : false );
} else {
// CRON export engine
// Order Status
if( isset( $_GET['order_status'] ) ) {
$order_filter_status = sanitize_text_field( $_GET['order_status'] );
$order_filter_status = explode( ',', $order_filter_status );
$export->args['order_status'] = $order_filter_status;
}
// Product
if( isset( $_GET['order_product'] ) ) {
$order_filter_product = sanitize_text_field( $_GET['order_product'] );
$order_filter_product = explode( ',', $order_filter_product );
$export->args['order_product'] = $order_filter_product;
}
// Order Date
if( isset( $_GET['order_date_from'] ) && isset( $_GET['order_date_to'] ) ) {
$order_filter_dates_from = $_GET['order_date_from'];
$order_filter_dates_to = $_GET['order_date_to'];
$export->args['order_dates_filter'] = 'manual';
$export->args['order_dates_from'] = ( !empty( $order_filter_dates_from ) ? sanitize_text_field( $order_filter_dates_from ) : false );
$export->args['order_dates_to'] = ( !empty( $order_filter_dates_to ) ? sanitize_text_field( $order_filter_dates_to ) : false );
}
// Billing Country
if( isset( $_GET['billing_country'] ) ) {
$order_filter_billing_country = sanitize_text_field( $_GET['billing_country'] );
$order_filter_billing_country = explode( ',', $order_filter_billing_country );
$export->args['order_billing_country'] = ( !empty( $order_filter_billing_country ) ? $order_filter_billing_country : false );
}
// Shipping Country
if( isset( $_GET['shipping_country'] ) ) {
$order_filter_shipping_country = sanitize_text_field( $_GET['shipping_country'] );
$order_filter_shipping_country = explode( ',', $order_filter_shipping_country );
$export->args['order_shipping_country'] = ( !empty( $order_filter_shipping_country ) ? $order_filter_shipping_country : false );
}
// Payment Gateway
if( isset( $_GET['payment_gateway'] ) ) {
$order_filter_payment = sanitize_text_field( $_GET['order_payment'] );
$order_filter_payment = explode( ',', $order_filter_payment );
$export->args['order_payment'] = ( !empty( $order_filter_payment ) ? $order_filter_payment : false );
}
// Shipping Method
if( isset( $_GET['shipping_method'] ) ) {
$order_filter_shipping = sanitize_text_field( $_GET['shipping_method'] );
$order_filter_shipping = explode( ',', $order_filter_shipping );
$export->args['order_shipping'] = ( !empty( $order_filter_shipping ) ? $order_filter_shipping : false );
}
}
break;
case 'subscription':
$export->args['subscription_orderby'] = $orderby;
$export->args['subscription_order'] = $order;
break;
case 'product_vendor':
$export->args['product_vendor_orderby'] = $orderby;
$export->args['product_vendor_order'] = $order;
break;
case 'commission':
// Commission Date
$commission_dates_filter = woo_ce_get_option( 'auto_commission_date', false );
if( $commission_dates_filter ) {
$export->args['commission_dates_filter'] = $commission_dates_filter;
switch( $commission_dates_filter ) {
case 'manual':
$commission_filter_dates_from = woo_ce_get_option( 'auto_commission_dates_from', false );
$commission_filter_dates_to = woo_ce_get_option( 'auto_commission_date_to', false );
$export->args['commission_dates_from'] = ( !empty( $commission_filter_dates_from ) ? sanitize_text_field( $commission_filter_dates_from ) : false );
$export->args['commission_dates_to'] = ( !empty( $commission_filter_dates_to ) ? sanitize_text_field( $commission_filter_dates_to ) : false );
break;
case 'variable':
$commission_filter_date_variable = woo_ce_get_option( 'auto_commission_date_variable', false );
$commission_filter_date_variable_length = woo_ce_get_option( 'auto_commission_date_variable_length', false );
$export->args['commission_dates_filter_variable'] = ( !empty( $commission_filter_date_variable ) ? absint( $commission_filter_date_variable ) : false );
$export->args['commission_dates_filter_variable_length'] = ( !empty( $commission_filter_date_variable_length ) ? sanitize_text_field( $commission_filter_date_variable_length ) : false );
break;
}
}
break;
case 'shipping_class':
$export->args['shipping_class_orderby'] = $orderby;
$export->args['shipping_class_order'] = $order;
break;
}
$export->filename = woo_ce_generate_filename( $export->type ) . '.' . $file_extension;
// Let's spin up PHPExcel for supported Export Types and Export Formats
if( in_array( $export->export_format, array( 'csv', 'xls', 'xlsx' ) ) ) {
// Check if we are using PHPExcel or not for supported Export Types
$dataset = woo_ce_export_dataset( $export->type );
if( !empty( $dataset ) ) {
// Check that PHPExcel is where we think it is
if( file_exists( WOO_CD_PATH . 'classes/PHPExcel.php' ) ) {
// Check if PHPExcel has already been loaded
if( !class_exists( 'PHPExcel' ) ) {
include_once( WOO_CD_PATH . 'classes/PHPExcel.php' );
} else {
error_log( sprintf( '[store-exporter-deluxe] %s: Warning: %s', $export->filename, __( 'The PHPExcel library was already loaded by another WordPress Plugin, if there\'s issues with your export file you know where to look.', 'woo_ce' ) ) );
}
$excel = new PHPExcel();
$excel->setActiveSheetIndex( 0 );
$excel->getActiveSheet()->setTitle( ucfirst( $export->type ) );
$row = 1;
// Skip headers if Heading Formatting is turned off
if( $export->header_formatting ) {
$col = 0;
foreach( $export->columns as $column ) {
$excel->getActiveSheet()->setCellValueByColumnAndRow( $col, $row, $column );
$excel->getActiveSheet()->getCellByColumnAndRow( $col, $row )->getStyle()->getFont()->setBold( true );
$excel->getActiveSheet()->getColumnDimensionByColumn( $col )->setAutoSize( true );
$col++;
}
$row = 2;
}
foreach( $dataset as $data ) {
$col = 0;
foreach( array_keys( $export->fields ) as $field ) {
$excel->getActiveSheet()->getCellByColumnAndRow( $col, $row )->getStyle()->getFont()->setBold( false );
if( $export->encoding == 'UTF-8' ) {
if( woo_ce_detect_value_string( ( isset( $data->$field ) ? $data->$field : null ) ) ) {
// Treat this cell as a string
$excel->getActiveSheet()->getCellByColumnAndRow( $col, $row )->setValueExplicit( ( isset( $data->$field ) ? wp_specialchars_decode( $data->$field ) : '' ), PHPExcel_Cell_DataType::TYPE_STRING );
} else {
$excel->getActiveSheet()->getCellByColumnAndRow( $col, $row )->setValue( ( isset( $data->$field ) ? wp_specialchars_decode( $data->$field ) : '' ) );
}
} else {
// PHPExcel only deals with UTF-8 regardless of encoding type
if( woo_ce_detect_value_string( ( isset( $data->$field ) ? $data->$field : null ) ) ) {
// Treat this cell as a string
$excel->getActiveSheet()->getCellByColumnAndRow( $col, $row )->setValueExplicit( ( isset( $data->$field ) ? utf8_encode( wp_specialchars_decode( $data->$field ) ) : '' ), PHPExcel_Cell_DataType::TYPE_STRING );
} else {
$excel->getActiveSheet()->getCellByColumnAndRow( $col, $row )->setValue( ( isset( $data->$field ) ? utf8_encode( wp_specialchars_decode( $data->$field ) ) : '' ) );
}
}
$col++;
}
$row++;
}
switch( $export->export_format ) {
case 'csv':
// We need to load this after the PHPExcel Class has been created
woo_cd_load_phpexcel_sed_csv_writer();
break;
}
$objWriter = PHPExcel_IOFactory::createWriter( $excel, $php_excel_format );
switch( $export->export_format ) {
case 'csv':
$objWriter->setUseBOM( true );
// Check if we're using a non-standard delimiter
if( $export->delimiter != ',' )
$objWriter->setDelimiter( $export->delimiter );
break;
case 'xlsx':
$objWriter->setPreCalculateFormulas( false );
break;
}
if( in_array( $gui, array( 'raw' ) ) ) {
$objWriter->save( 'php://output' );
} else {
// Save to file and insert to WordPress Media
$temp_filename = tempnam( apply_filters( 'woo_ce_sys_get_temp_dir', sys_get_temp_dir() ), 'tmp' );
// Check if we were given a temporary filename
if( $temp_filename == false ) {
$message = sprintf( __( 'We could not create a temporary export file in %s, ensure that WordPress can read and write files here and try again.', 'woo_ce' ), apply_filters( 'woo_ce_sys_get_temp_dir', sys_get_temp_dir() ) );
error_log( sprintf( '[store-exporter-deluxe] %s: Error: %s', $export->filename, $message ) );
} else {
$objWriter->save( $temp_filename );
$bits = file_get_contents( $temp_filename );
}
unlink( $temp_filename );
}
// Clean up PHPExcel
$excel->disconnectWorksheets();
unset( $objWriter, $excel );
} else {
error_log( sprintf( '[store-exporter-deluxe] %s: Error: %s', $export->filename, __( 'We couldn\'t load the PHPExcel library, this file should be present.' ) ) );
}
}
// Run the default engine for the XML and RSS export formats
} else if( in_array( $export->export_format, array( 'xml', 'rss' ) ) ) {
// Check if SimpleXMLElement is present
if( class_exists( 'SED_SimpleXMLElement' ) ) {
if( $export->export_format == 'xml' ) {
$xml = new SED_SimpleXMLElement( sprintf( apply_filters( 'woo_ce_export_xml_first_line', '<?xml version="1.0" encoding="%s"?><%s/>' ), esc_attr( $export->encoding ), esc_attr( apply_filters( 'woo_ce_export_xml_store_node', 'store' ) ) ) );
if( woo_ce_get_option( 'xml_attribute_url', 1 ) )
$xml->addAttribute( 'url', get_site_url() );
if( woo_ce_get_option( 'xml_attribute_date', 1 ) )
$xml->addAttribute( 'date', date( 'Y-m-d' ) );
if( woo_ce_get_option( 'xml_attribute_time', 0 ) )
$xml->addAttribute( 'time', date( 'H:i:s' ) );
if( woo_ce_get_option( 'xml_attribute_title', 1 ) )
$xml->addAttribute( 'name', htmlspecialchars( get_bloginfo( 'name' ) ) );
if( woo_ce_get_option( 'xml_attribute_export', 1 ) )
$xml->addAttribute( 'export', htmlspecialchars( $export->type ) );
if( woo_ce_get_option( 'xml_attribute_orderby', 1 ) )
$xml->addAttribute( 'orderby', $orderby );
if( woo_ce_get_option( 'xml_attribute_order', 1 ) )
$xml->addAttribute( 'order', $order );
if( woo_ce_get_option( 'xml_attribute_limit', 1 ) )
$xml->addAttribute( 'limit', $export->limit_volume );
if( woo_ce_get_option( 'xml_attribute_offset', 1 ) )
$xml->addAttribute( 'offset', $export->offset );
$xml = woo_ce_export_dataset( $export->type, $xml );
} else if( $export->export_format == 'rss' ) {
$xml = new SED_SimpleXMLElement( sprintf( apply_filters( 'woo_ce_export_rss_first_line', '<?xml version="1.0" encoding="%s"?><rss version="2.0"%s/>' ), esc_attr( $export->encoding ), ' xmlns:g="http://base.google.com/ns/1.0"' ) );
$child = $xml->addChild( apply_filters( 'woo_ce_export_rss_channel_node', 'channel' ) );
$child->addChild( 'title', woo_ce_get_option( 'rss_title', '' ) );
$child->addChild( 'link', woo_ce_get_option( 'rss_link', '' ) );
$child->addChild( 'description', woo_ce_get_option( 'rss_description', '' ) );
$bits = woo_ce_export_dataset( $export->type, $child );
}
$bits = woo_ce_format_xml( $xml );
} else {
$bits = false;
error_log( '[store-exporter-deluxe] Error: The SimpleXMLElement class does not exist for XML file generation' );
}
}
if( !empty( $bits ) ) {
$output = '<p>' . __( 'Export completed successfully.', 'woo_ce' ) . '</p>';
if( $gui == 'gui' )
$output .= '<textarea readonly="readonly">' . esc_textarea( str_replace( '<br />', "\n", $bits ) ) . '</textarea>';
} else {
if( $gui == 'gui' ) {
$output = sprintf( '<p>%s</p>', __( 'No export entries were found.', 'woo_ce' ) );
} else {
error_log( sprintf( '[store-exporter-deluxe] %s: Warning: %s', $export->filename, __( 'No export entries were found', 'woo_ce' ) ) );
return false;
}
}
}
}
// Return raw export to browser without file headers
if( $gui == 'raw' && !empty( $bits ) ) {
return $bits;
// Return export as file download to browser
} else if( $gui == 'download' && !empty( $bits ) ) {
woo_ce_generate_file_headers( $post_mime_type );
if( defined( 'DOING_AJAX' ) || get_transient( WOO_CD_PREFIX . '_single_export_format' ) !== false )
echo $bits;
else
return $bits;
// HTTP Post export contents to remote URL
} else if( $gui == 'post' && !empty( $bits ) ) {
$args = apply_filters( 'woo_ce_cron_export_post_args', array(
'method' => 'POST',
'timeout' => 60,
'redirection' => 0,
'httpversion' => '1.0',
'sslverify' => false,
'blocking' => true,
'headers' => array(
'accept' => $post_mime_type,
'content-type' => $post_mime_type
),
'body' => $bits,
'cookies' => array(),
'user-agent' => sprintf( 'WordPress/%s', $GLOBALS['wp_version'] ),
) );
$response = wp_remote_post( $export->to, $args );
if( is_wp_error( $response ) ) {
error_log( sprintf( '[store-exporter-deluxe] %s: Error: %s', $export->filename, $response->get_error_message() ) );
return false;
} else {
error_log( sprintf( '[store-exporter-deluxe] %s: Success: %s', $export->filename, sprintf( __( 'Remote POST sent to %s', 'woo_ce' ), $export->to ) ) );
}
// Output to screen in friendly design with on-screen error responses
} else if( $gui == 'gui' ) {
if( file_exists( WOO_CD_PATH . 'templates/admin/cron.php' ) ) {
include_once( WOO_CD_PATH . 'templates/admin/cron.php' );
} else {
error_log( sprintf( '[store-exporter-deluxe] %s: Error: %s', $export->filename, __( 'Could not load template file within /templates/admin/cron.php', 'woo_ce' ) ) );
}
if( isset( $output ) )
echo $output;
echo '
</body>
</html>';
// Save export file to WordPress Media before sending/saving/etc. action
} else if( in_array( $gui, array( 'gui', 'archive', 'url', 'file', 'email', 'ftp' ) ) ) {
$upload = false;
if( $export->filename && !empty( $bits ) ) {
$post_ID = woo_ce_save_file_attachment( $export->filename, $post_mime_type );
$upload = wp_upload_bits( $export->filename, null, $bits );
if( ( $post_ID == false ) || $upload['error'] ) {
wp_delete_attachment( $post_ID, true );
error_log( sprintf( '[store-exporter-deluxe] %s: Error: %s', $export->filename, $upload['error'] ) );
return false;
}
if( file_exists( ABSPATH . 'wp-admin/includes/image.php' ) ) {
include_once( ABSPATH . 'wp-admin/includes/image.php' );
$attach_data = wp_generate_attachment_metadata( $post_ID, $upload['file'] );
wp_update_attachment_metadata( $post_ID, $attach_data );
update_attached_file( $post_ID, $upload['file'] );
if( !empty( $post_ID ) ) {
woo_ce_save_file_guid( $post_ID, $export->type, $upload['url'] );
woo_ce_save_file_details( $post_ID );
}
} else {
error_log( sprintf( '[store-exporter-deluxe] %s: Error: %s', $export->filename, __( 'Could not load image.php within /wp-admin/includes/image.php', 'woo_ce' ) ) );
}
}
// Return URL to export file
if( $gui == 'url' )
return $upload['url'];
// Return system path to export file
if( $gui == 'file' )
return $upload['file'];
// E-mail export file to preferred address or WordPress site owner address
if( $gui == 'email' ) {
global $woocommerce;
$mailer = $woocommerce->mailer();
$subject = woo_ce_cron_email_subject( $export->type, $export->filename );
$attachment = $upload['file'];
$email_heading = sprintf( __( 'Export: %s', 'woo_ce' ), ucwords( $export->type ) );
$recipient_name = apply_filters( 'woo_ce_email_recipient_name', __( 'there', 'woo_ce' ) );
$email_contents = apply_filters( 'woo_ce_email_contents', wpautop( __( 'Please find attached your export ready to review.', 'woo_ce' ) ) );
// Buffer
ob_start();
// Get mail template
if( file_exists( WOO_CD_PATH . 'templates/emails/scheduled_export.php' ) ) {
include_once( WOO_CD_PATH . 'templates/emails/scheduled_export.php' );
} else {
echo wpautop( sprintf( __( 'Hi %s', 'woo_ce' ), $recipient_name ) );
echo $email_contents;
error_log( sprintf( '[store-exporter-deluxe] %s: Error: %s', $export->filename, sprintf( __( 'Could not load template file %s within %s, defaulted to hard coded template.', 'woo_ce' ), 'scheduled_export.php', '/templates/emails/...' ) ) );
}
// Get contents
$message = ob_get_clean();
// Send the mail using WooCommerce mailer
if( function_exists( 'woocommerce_mail' ) ) {
woocommerce_mail( $export->to, $subject, $message, null, $attachment );
} else {
// Default to wp_mail()
add_filter( 'wp_mail_content_type', 'woo_ce_set_html_content_type' );
wp_mail( $export->to, $subject, $message, null, $attachment );
remove_filter( 'wp_mail_content_type', 'woo_ce_set_html_content_type' );
}
// Delete the export file regardless of whether e-mail was successful or not
wp_delete_attachment( $post_ID, true );
error_log( sprintf( '[store-exporter-deluxe] %s: Success: %s', $export->filename, sprintf( __( 'Scheduled export e-mail of %s sent to %s', 'woo_ce' ), $export->filename, $export->to ) ) );
}
if( $gui == 'ftp' ) {
// Load up our FTP/SFTP resources
$host = woo_ce_get_option( 'auto_ftp_method_host', '' );
if( !empty( $host ) )
$host = woo_ce_format_ftp_host( $host );
$port = woo_ce_get_option( 'auto_ftp_method_port', '' );
$port = ( !empty( $port ) ? absint( $port ) : false );
$user = woo_ce_get_option( 'auto_ftp_method_user', '' );
$pass = woo_ce_get_option( 'auto_ftp_method_pass', '' );
$path = woo_ce_get_option( 'auto_ftp_method_path', '' );
$filename = woo_ce_get_option( 'auto_ftp_method_filename', '' );
// Switch to fixed export filename if provided
if( !empty( $filename ) )
$export->filename = woo_ce_generate_filename( $export->type, $filename ) . '.' . $file_extension;
// Check what protocol are we using; FTP or SFTP?
$protocol = woo_ce_get_option( 'auto_ftp_method_protocol', 'ftp' );
switch( $protocol ) {
case 'ftp':
default:
// Check if ftp_connect() is available
if( function_exists( 'ftp_connect' ) ) {
$passive = woo_ce_get_option( 'auto_ftp_method_passive', '' );
$timeout = woo_ce_get_option( 'auto_ftp_method_timeout', '' );
if( $connection = @ftp_connect( $host, $port ) ) {
// Update the FTP timeout if available and if a timeout was provided at export
$remote_timeout = ftp_get_option( $connection, FTP_TIMEOUT_SEC );
$timeout = absint( $timeout );
if( $remote_timeout !== false && !empty( $timeout ) ) {
// Compare the server timeout and the timeout provided at export
if( $remote_timeout <> $timeout ) {
if( ftp_set_option( $connection, FTP_TIMEOUT_SEC, $timeout ) == false )
error_log( sprintf( '[store-exporter-deluxe] %s: Warning: %s', $export->filename, sprintf( __( 'Could not change the FTP server timeout on %s', 'woo_ce' ), $host ) ) );
}
}
unset( $remote_timeout );
if( ftp_login( $connection, $user, $pass ) ) {
// Check if Transfer Mode is set to Auto/Pasive and if passive mode is available
if( in_array( $passive, array( 'auto', 'passive' ) ) ) {
$features = ftp_raw( $connection, 'FEAT' );
if( !empty( $features ) ) {
if( in_array( 'PASV', $features ) ) {
if( ftp_pasv( $connection, true ) == false )
error_log( sprintf( '[store-exporter-deluxe] %s: Warning: %s', 'woo_ce', $export->filename, sprintf( __( 'Could not switch to FTP passive mode on %s', 'woo_ce' ), $host ) ) );
}
}
}
// Change directory if neccesary
if( !empty( $directory ) ) {
$current_directory = ftp_pwd( $connection );
if( $current_directory !== false && @ftp_chdir( $connection, $path ) )
ftp_chdir( $connection, $path );
}
if( ftp_put( $connection, sprintf( '%s/%s', $path, $export->filename ), $upload['file'], FTP_ASCII ) ) {
error_log( sprintf( '[store-exporter-deluxe] %s: Success: %s', $export->filename, sprintf( __( 'Scheduled export of %s to %s via FTP uploaded', 'woo_ce' ), $export->filename, $path ) ) );
} else {
$export->error = sprintf( __( 'There was a problem uploading %s to %s via FTP, response: %s', 'woo_ce' ), $export->filename, $path, woo_ce_error_get_last_message() );
error_log( sprintf( '[store-exporter-deluxe] %s: Error: %s', $export->filename, $export->error ) );
}
} else {
$export->error = sprintf( __( 'Login incorrect for user %s on FTP server at %s, response: %s', 'woo_ce' ), $user, $host, woo_ce_error_get_last_message() );
error_log( sprintf( '[store-exporter-deluxe] %s: Error: %s', $export->filename, $export->error ) );
}
} else {
$export->error = sprintf( __( 'There was a problem connecting to %s via FTP', 'woo_ce' ), $host );
error_log( sprintf( '[store-exporter-deluxe] %s: Error: %s', $export->filename, $export->error ) );
}
} else {
$export->error = __( 'The function ftp_connect() is disabled within your WordPress site, cannot upload to FTP server', 'woo_ce' );
error_log( __( '[store-exporter-deluxe] %s: Error: %s', 'woo_ce' ), $export->filename, $export->error );
}
break;
case 'sftp':
// Check if ssh2_connect() is available
if( function_exists( 'ssh2_connect' ) ) {
if( $connection = @ssh2_connect( $host, $port ) ) {
if( ssh2_auth_password( $connection, $user, $pass ) ) {
// Initialize SFTP subsystem
if( $session = ssh2_sftp( $connection ) ) {
if( $handle = fopen( sprintf( 'ssh2.sftp://%s/%s/%s', $session, $path, $export->filename ), 'w+' ) ) {
error_log( sprintf( '[store-exporter-deluxe] %s: Success: %s', $export->filename, sprintf( __( 'Scheduled export of %s to %s via SFTP uploaded', 'woo_ce' ), $export->filename, $path ) ) );
} else {
$export->error = sprintf( __( 'There was a problem uploading %s to %s via SFTP', 'woo_ce' ), $export->filename, $path );
error_log( sprintf( '[store-exporter-deluxe] %s: Error: %s', $export->filename, $export->error ) );
}
} else {
$export->error = sprintf( __( 'Could not initialize SFTP subsystem on SFTP server at %s', 'woo_ce' ), $host );
error_log( sprintf( '[store-exporter-deluxe] %s: Error: %s', $export->filename, $export->error ) );
}
} else {
$export->error = sprintf( __( 'Login incorrect for user %s on SFTP server at %s', 'woo_ce' ), $user, $host );
error_log( sprintf( '[store-exporter-deluxe] %s: Error: %s', $export->filename, $export->error ) );
}
} else {
$export->error = sprintf( __( 'There was a problem connecting to %s via SFTP', 'woo_ce' ), $host );
error_log( sprintf( '[store-exporter-deluxe] %s: Error: %s', $export->filename, $export->error ) );
}
} else {
$export->error = __( 'The function ssh2_connect() is disabled within your WordPress site, cannot upload to SFTP server', 'woo_ce' );
error_log( sprintf( __( '[store-exporter-deluxe] %s: Error: %s', 'woo_ce' ), $export->filename, $export->error ) );
}
break;
}
// Delete the export file regardless of whether upload was successful or not
wp_delete_attachment( $post_ID, true );
}
}
// Only include scheduled exports to the Recent Scheduled Exports list
if( $export->scheduled_export ) {
$recent_exports = woo_ce_get_option( 'recent_scheduled_exports', array() );
if( empty( $recent_exports ) )
$recent_exports = array();
$size = count( $recent_exports );
// Get the limit from the WordPress Dashboard widget
if( !$widget_options = get_option( 'woo_ce_recent_scheduled_export_widget_options', array() ) ) {
$widget_options = array(
'number' => 5
);
}
// Check if we have maxed out our recent scheduled exports
if( $size >= $widget_options['number'] )
array_shift( $recent_exports );
$post_ID = ( isset( $post_ID ) ? $post_ID : 0 );
$recent_exports[] = array(
'post_id' => ( empty( $export->error ) ? $post_ID : 0 ),
'name' => $export->filename,
'date' => time(),
'method' => $gui,
'error' => $export->error
);
woo_ce_update_option( 'recent_scheduled_exports', $recent_exports );
}
delete_option( WOO_CD_PREFIX . '_exported' );
// If the CRON process gets this far, pass on the good news!
return true;
}
/**
* Sets FTP option value
*
* @param int $option Option id. Supported are: <code>FTP_TIMEOUT_SEC</code>, <code>FTP_AUTOSEEK</code>
* @param type $value Value to set
* @throws cFTP_Exception
*
* @return cFTP_Session This
*/
public function setOptionValue( $option, $value )
{
$success = @ftp_get_option($this->handle, $option, $value);
if( $success === false )
throw new cFTP_Exception( "Could not set option value", 10 );
return $this;
}
/**
* Retrieves various runtime behaviours of the current FTP stream
* TIMEOUT_SEC | AUTOSEEK
*
* @param mixed $option
*
* @return mixed
*/
public function getOption($option)
{
switch ($option) {
case FTPClient::TIMEOUT_SEC:
case FTPClient::AUTOSEEK:
$result = @ftp_get_option($this->connection, $option);
return $result;
break;
default:
throw new Exception('Unsupported option');
break;
}
}
<?php
$ftp = null;
var_dump(ftp_connect(array()));
var_dump(ftp_connect('127.0.0.1', 0, -3));
var_dump(ftp_raw($ftp));
var_dump(ftp_mkdir($ftp));
var_dump(ftp_rmdir($ftp));
var_dump(ftp_nlist($ftp));
var_dump(ftp_rawlist($ftp));
var_dump(ftp_fget($ftp));
var_dump(ftp_nb_fget($ftp));
var_dump(ftp_nb_get($ftp));
var_dump(ftp_pasv($ftp));
var_dump(ftp_nb_continue());
var_dump(ftp_fput());
var_dump(ftp_nb_fput($ftp));
var_dump(ftp_put($ftp));
var_dump(ftp_nb_put($ftp));
var_dump(ftp_size($ftp));
var_dump(ftp_mdtm($ftp));
var_dump(ftp_rename($ftp));
var_dump(ftp_site($ftp));
var_dump(ftp_set_option($ftp));
var_dump(ftp_get_option($ftp));
/**
* 获取FTP选项
*
* @author Garbin
* @param string $option
* @return mixed
*/
function get_option($option)
{
return ftp_get_option($this->_connection, $option);
}
public function getOption($option, $value)
{
if (!$this->getConn()) {
throw new \Exception('No etablished connexion ...');
}
if ($option !== FTP_TIMEOUT_SEC && $option !== FTP_AUTOSEEK) {
throw new \Exception('Invalid option');
}
ftp_get_option($this->getConn(), $option, $value);
}
