FreenetIS

<?php defined('SYSPATH') or die('No direct script access.');

/**

* Server helper class.

*

* $Id: server.php

*

* @package Core

* @author Sevcik Roman

* @copyright (c) 2009 Sevcik Roman

*/

//spurce from http://my.opera.com/Knedle/blog/show.dml/451690

class server

{

public function http_user_agent()

{

return $_SERVER['HTTP_USER_AGENT'];

}

public function http_host()

{

return $_SERVER['HTTP_HOST'];

}

public function server_software()

{

return $_SERVER['SERVER_SOFTWARE'];

}

public function server_name()

{

return $_SERVER['SERVER_NAME'];

}

public function server_addr()

{

return $_SERVER['SERVER_ADDR'];

}

public function server_port()

{

return $_SERVER['SERVER_PORT'];

}

public function remote_addr()

{

return $_SERVER['REMOTE_ADDR'];

}

}

<?php defined('SYSPATH') OR die('No direct access allowed.');

/**

* SwiftMailer driver, used with the email helper.

*

* @see http://www.swiftmailer.org/wikidocs/v3/connections/nativemail

* @see http://www.swiftmailer.org/wikidocs/v3/connections/sendmail

* @see http://www.swiftmailer.org/wikidocs/v3/connections/smtp

*

* Valid drivers are: native, sendmail, smtp

*/

$config['driver'] = 'smtp';

/**

* To use secure connections with SMTP, set "port" to 465 instead of 25.

* To enable TLS, set "encryption" to "tls".

*

* Driver options:

* @param null native: no options

* @param string sendmail: executable path, with -bs or equivalent attached

* @param array smtp: hostname, (username), (password), (port), (auth), (encryption)

*/

$config['options'] = array('hostname'=>'smtp.slfree.czf', 'port'=>'25');

<?php

class Scheduler_Controller extends Controller

{

function index()

{

url::redirect(url::base());

}

public function run()

{

//if (server::remote_addr() != "127.0.0.1" )

//die();

$this->parse_ebank_account("http://www.rb.cz/firemni-finance/transparentni-ucty/?root=firemni-finance&item1=transparentni-ucty&tr_acc=vypis&account_number=184932848");

}

private function parse_ebank_account($url)

{

$ucet = new Parser_Ebanka();

$ucet->set_callback('ShowData');

print"<table>";

$ucet->parse($url);

print"</table>";

}

private function ShowData($res)

{

print sprintf("<tr><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td>%s</td></tr>",$res->date_time, $res->comment, $res->name, $res->typ, $res->variable_symbol, $res->constant_symbol, $res->specific_symbol, $res->castka, $res->poplatek);

}

}

if (!$this->session->get('user_id', 0) && url_lang::current()!='login' && url_lang::current()!='registration' && url_lang::current()!='scheduler/run')

if ($this->acl_check_2D('menu', 'my_devices')) $myMenu .= ' <li>'.html::anchor(url_lang::base().'devices/show_by_member/'.$this->session->get('member_id'), url_lang::lang('texts.My devices')).'</li>';

</li>';

<li>'.html::anchor(url_lang::base().'accounts/main_accounts/operating', url_lang::lang('texts.Operating account')).'</li>

<li>'.html::anchor(url_lang::base().'users', url_lang::lang('texts.Users')).'</li>';

<?php defined('SYSPATH') or die('No direct script access.');

/**

* SwiftMailer driver, used with the email helper.

*

* @see http://www.swiftmailer.org/wikidocs/v3/connections/nativemail

* @see http://www.swiftmailer.org/wikidocs/v3/connections/sendmail

* @see http://www.swiftmailer.org/wikidocs/v3/connections/smtp

*

* Valid drivers are: native, sendmail, smtp

*/

$config['driver'] = 'native';

/**

* Driver options:

* @param null native: no options

* @param string sendmail: executable path, with -bs or equivalent attached

* @param array smtp: hostname, (username), (password), (port)

*/

$config['options'] = NULL;

<?php

/**

* Swift Mailer Core Component.

* Please read the LICENSE file

* @copyright Chris Corbyn <chris@w3style.co.uk>

* @author Chris Corbyn <chris@w3style.co.uk>

* @package Swift

* @version 3.3.2

* @license GNU Lesser General Public License

*/

require_once dirname(__FILE__) . "/Swift/ClassLoader.php";

Swift_ClassLoader::load("Swift_LogContainer");

Swift_ClassLoader::load("Swift_ConnectionBase");

Swift_ClassLoader::load("Swift_BadResponseException");

Swift_ClassLoader::load("Swift_Cache");

Swift_ClassLoader::load("Swift_CacheFactory");

Swift_ClassLoader::load("Swift_Message");

Swift_ClassLoader::load("Swift_RecipientList");

Swift_ClassLoader::load("Swift_BatchMailer");

Swift_ClassLoader::load("Swift_Events");

Swift_ClassLoader::load("Swift_Events_Listener");

/**

* Swift is the central component in the Swift library.

* @package Swift

* @author Chris Corbyn <chris@w3style.co.uk>

* @version 3.3.2

*/

class Swift

{

/**

* The version number.

*/

const VERSION = "3.3.2";

/**

* Constant to flag Swift not to try and connect upon instantiation

*/

const NO_START = 2;

/**

* Constant to tell Swift not to perform the standard SMTP handshake upon connect

*/

const NO_HANDSHAKE = 4;

/**

* Constant to ask Swift to start logging

*/

const ENABLE_LOGGING = 8;

/**

* Constant to prevent postConnect() being run in the connection

*/

const NO_POST_CONNECT = 16;

/**

* The connection object currently active

* @var Swift_Connection

*/

public $connection = null;

/**

* The domain name of this server (should technically be a FQDN)

* @var string

*/

protected $domain = null;

/**

* Flags to change the behaviour of Swift

* @var int

*/

protected $options;

/**

* Loaded plugins, separated into containers according to roles

* @var array

*/

protected $listeners = array();

/**

* Constructor

* @param Swift_Connection The connection object to deal with I/O

* @param string The domain name of this server (the client) as a FQDN

* @param int Optional flags

* @throws Swift_ConnectionException If a connection cannot be established or the connection is behaving incorrectly

*/

public function __construct(Swift_Connection $conn, $domain=false, $options=null)

{

$this->initializeEventListenerContainer();

$this->setOptions($options);

$log = Swift_LogContainer::getLog();

if ($this->hasOption(self::ENABLE_LOGGING) && !$log->isEnabled())

{

$log->setLogLevel(Swift_Log::LOG_NETWORK);

}

if (!$domain) $domain = !empty($_SERVER["SERVER_ADDR"]) ? "[" . $_SERVER["SERVER_ADDR"] . "]" : "localhost.localdomain";

$this->setDomain($domain);

$this->connection = $conn;

if ($conn && !$this->hasOption(self::NO_START))

{

if ($log->hasLevel(Swift_Log::LOG_EVERYTHING)) $log->add("Trying to connect...", Swift_Log::NORMAL);

$this->connect();

}

}

/**

* Populate the listeners array with the defined listeners ready for plugins

*/

protected function initializeEventListenerContainer()

{

Swift_ClassLoader::load("Swift_Events_ListenerMapper");

foreach (Swift_Events_ListenerMapper::getMap() as $interface => $method)

{

if (!isset($this->listeners[$interface]))

$this->listeners[$interface] = array();

}

}

/**

* Add a new plugin to Swift

* Plugins must implement one or more event listeners

* @param Swift_Events_Listener The plugin to load

*/

public function attachPlugin(Swift_Events_Listener $plugin, $id)

{

foreach (array_keys($this->listeners) as $key)

{

$listener = "Swift_Events_" . $key;

Swift_ClassLoader::load($listener);

if ($plugin instanceof $listener) $this->listeners[$key][$id] = $plugin;

}

}

/**

* Get an attached plugin if it exists

* @param string The id of the plugin

* @return Swift_Event_Listener

*/

public function getPlugin($id)

{

foreach ($this->listeners as $type => $arr)

{

if (isset($arr[$id])) return $this->listeners[$type][$id];

}

return null; //If none found

}

/**

* Remove a plugin attached under the ID of $id

* @param string The ID of the plugin

*/

public function removePlugin($id)

{

foreach ($this->listeners as $type => $arr)

{

if (isset($arr[$id]))

{

$this->listeners[$type][$id] = null;

unset($this->listeners[$type][$id]);

}

}

}

/**

* Send a new type of event to all objects which are listening for it

* @param Swift_Events The event to send

* @param string The type of event

*/

public function notifyListeners($e, $type)

{

Swift_ClassLoader::load("Swift_Events_ListenerMapper");

if (!empty($this->listeners[$type]) && $notifyMethod = Swift_Events_ListenerMapper::getNotifyMethod($type))

{

$e->setSwift($this);

foreach ($this->listeners[$type] as $k => $listener)

{

$listener->$notifyMethod($e);

}

}

else $e = null;

}

/**

* Check if an option flag has been set

* @param string Option name

* @return boolean

*/

public function hasOption($option)

{

return ($this->options & $option);

}

/**

* Adjust the options flags

* E.g. $obj->setOptions(Swift::NO_START | Swift::NO_HANDSHAKE)

* @param int The bits to set

*/

public function setOptions($options)

{

$this->options = (int) $options;

}

/**

* Get the current options set (as bits)

* @return int

*/

public function getOptions()

{

return (int) $this->options;

}

/**

* Set the FQDN of this server as it will identify itself

* @param string The FQDN of the server

*/

public function setDomain($name)

{

$this->domain = (string) $name;

}

/**

* Attempt to establish a connection with the service

* @throws Swift_ConnectionException If the connection cannot be established or behaves oddly

*/

public function connect()

{

$this->connection->start();

$greeting = $this->command("", 220);

if (!$this->hasOption(self::NO_HANDSHAKE))

{

$this->handshake($greeting);

}

Swift_ClassLoader::load("Swift_Events_ConnectEvent");

$this->notifyListeners(new Swift_Events_ConnectEvent($this->connection), "ConnectListener");

}

/**

* Disconnect from the MTA

* @throws Swift_ConnectionException If the connection will not stop

*/

public function disconnect()

{

$this->command("QUIT");

$this->connection->stop();

Swift_ClassLoader::load("Swift_Events_DisconnectEvent");

$this->notifyListeners(new Swift_Events_DisconnectEvent($this->connection), "DisconnectListener");

}

/**

* Throws an exception if the response code wanted does not match the one returned

* @param Swift_Event_ResponseEvent The full response from the service

* @param int The 3 digit response code wanted

* @throws Swift_BadResponseException If the code does not match

*/

protected function assertCorrectResponse(Swift_Events_ResponseEvent $response, $codes)

{

$codes = (array)$codes;

if (!in_array($response->getCode(), $codes))

{

$log = Swift_LogContainer::getLog();

$error = "Expected response code(s) [" . implode(", ", $codes) . "] but got response [" . $response->getString() . "]";

if ($log->hasLevel(Swift_Log::LOG_ERRORS)) $log->add($error, Swift_Log::ERROR);

throw new Swift_BadResponseException($error);

}

}

/**

* Have a polite greeting with the server and work out what it's capable of

* @param Swift_Events_ResponseEvent The initial service line respoonse

* @throws Swift_ConnectionException If conversation is not going very well

*/

protected function handshake(Swift_Events_ResponseEvent $greeting)

{

if ($this->connection->getRequiresEHLO() || strpos($greeting->getString(), "ESMTP"))

$this->setConnectionExtensions($this->command("EHLO " . $this->domain, 250));

else $this->command("HELO " . $this->domain, 250);

//Connection might want to do something like authenticate now

if (!$this->hasOption(self::NO_POST_CONNECT)) $this->connection->postConnect($this);

}

/**

* Set the extensions which the service reports in the connection object

* @param Swift_Events_ResponseEvent The list of extensions as reported by the service

*/

protected function setConnectionExtensions(Swift_Events_ResponseEvent $list)

{

$le = (strpos($list->getString(), "\r\n") !== false) ? "\r\n" : "\n";

$list = explode($le, $list->getString());

for ($i = 1, $len = count($list); $i < $len; $i++)

{

$extension = substr($list[$i], 4);

$attributes = split("[ =]", $extension);

$this->connection->setExtension($attributes[0], (isset($attributes[1]) ? array_slice($attributes, 1) : array()));

}

}

/**

* Execute a command against the service and get the response

* @param string The command to execute (leave off any CRLF!!!)

* @param int The code to check for in the response, if any. -1 indicates that no response is wanted.

* @return Swift_Events_ResponseEvent The server's response (could be multiple lines)

* @throws Swift_ConnectionException If a code was expected but does not match the one returned

*/

public function command($command, $code=null)

{

$log = Swift_LogContainer::getLog();

Swift_ClassLoader::load("Swift_Events_CommandEvent");

if ($command !== "")

{

$command_event = new Swift_Events_CommandEvent($command, $code);

$command = null; //For memory reasons

$this->notifyListeners($command_event, "BeforeCommandListener");

if ($log->hasLevel(Swift_Log::LOG_NETWORK) && $code != -1) $log->add($command_event->getString(), Swift_Log::COMMAND);

$end = ($code != -1) ? "\r\n" : null;

$this->connection->write($command_event->getString(), $end);

$this->notifyListeners($command_event, "CommandListener");

}

if ($code == -1) return null;

Swift_ClassLoader::load("Swift_Events_ResponseEvent");

$response_event = new Swift_Events_ResponseEvent($this->connection->read());

$this->notifyListeners($response_event, "ResponseListener");

if ($log->hasLevel(Swift_Log::LOG_NETWORK)) $log->add($response_event->getString(), Swift_Log::RESPONSE);

if ($command !== "" && $command_event->getCode() !== null)

$this->assertCorrectResponse($response_event, $command_event->getCode());

return $response_event;

}

/**

* Reset a conversation which has gone badly

* @throws Swift_ConnectionException If the service refuses to reset

*/

public function reset()

{

$this->command("RSET", 250);

}

/**

* Send a message to any number of recipients

* @param Swift_Message The message to send. This does not need to (and shouldn't really) have any of the recipient headers set.

* @param mixed The recipients to send to. Can be a string, Swift_Address or Swift_RecipientList. Note that all addresses apart from Bcc recipients will appear in the message headers

* @param mixed The address to send the message from. Can either be a string or an instance of Swift_Address.

* @return int The number of successful recipients

* @throws Swift_ConnectionException If sending fails for any reason.

*/

public function send(Swift_Message $message, $recipients, $from)

{

Swift_ClassLoader::load("Swift_Message_Encoder");

if (is_string($recipients) && preg_match("/^" . Swift_Message_Encoder::CHEAP_ADDRESS_RE . "\$/", $recipients))

{

$recipients = new Swift_Address($recipients);

}

elseif (!($recipients instanceof Swift_AddressContainer))

throw new Exception("The recipients parameter must either be a valid string email address, ".

"an instance of Swift_RecipientList or an instance of Swift_Address.");

if (is_string($from) && preg_match("/^" . Swift_Message_Encoder::CHEAP_ADDRESS_RE . "\$/", $from))

{

$from = new Swift_Address($from);

}

elseif (!($from instanceof Swift_Address))

throw new Exception("The sender parameter must either be a valid string email address or ".

"an instance of Swift_Address.");

$log = Swift_LogContainer::getLog();

if (!$message->getEncoding() && !$this->connection->hasExtension("8BITMIME"))

{

$message->setEncoding("QP", true, true);

}

$list = $recipients;

if ($recipients instanceof Swift_Address)

{

$list = new Swift_RecipientList();

$list->addTo($recipients);

}

Swift_ClassLoader::load("Swift_Events_SendEvent");

$send_event = new Swift_Events_SendEvent($message, $list, $from, 0);

$this->notifyListeners($send_event, "BeforeSendListener");

$to = $cc = array();

if (!($has_from = $message->getFrom())) $message->setFrom($from);

if (!($has_return_path = $message->getReturnPath())) $message->setReturnPath($from->build(true));

if (!($has_reply_to = $message->getReplyTo())) $message->setReplyTo($from);

if (!($has_message_id = $message->getId())) $message->generateId();

$this->command("MAIL FROM: " . $message->getReturnPath(true), 250);

$failed = 0;

$sent = 0;

$tmp_sent = 0;

$it = $list->getIterator("to");

while ($it->hasNext())

{

$it->next();

$address = $it->getValue();

$to[] = $address->build();

try {

$this->command("RCPT TO: " . $address->build(true), 250);

$tmp_sent++;

} catch (Swift_BadResponseException $e) {

$failed++;

$send_event->addFailedRecipient($address->getAddress());

if ($log->hasLevel(Swift_Log::LOG_FAILURES)) $log->addfailedRecipient($address->getAddress());

}

}

$it = $list->getIterator("cc");

while ($it->hasNext())

{

$it->next();

$address = $it->getValue();

$cc[] = $address->build();

try {

$this->command("RCPT TO: " . $address->build(true), 250);

$tmp_sent++;

} catch (Swift_BadResponseException $e) {

$failed++;

$send_event->addFailedRecipient($address->getAddress());

if ($log->hasLevel(Swift_Log::LOG_FAILURES)) $log->addfailedRecipient($address->getAddress());

}

}

if ($failed == (count($to) + count($cc)))

{

$this->reset();

$this->notifyListeners($send_event, "SendListener");

return 0;

}

if (!($has_to = $message->getTo()) && !empty($to)) $message->setTo($to);

if (!($has_cc = $message->getCc()) && !empty($cc)) $message->setCc($cc);

$this->command("DATA", 354);

$data = $message->build();

while (false !== $bytes = $data->read())

$this->command($bytes, -1);

if ($log->hasLevel(Swift_Log::LOG_NETWORK)) $log->add("<MESSAGE DATA>", Swift_Log::COMMAND);

try {

$this->command("\r\n.", 250);

$sent += $tmp_sent;

} catch (Swift_BadResponseException $e) {

$failed += $tmp_sent;

}

$tmp_sent = 0;

$has_bcc = $message->getBcc();

$it = $list->getIterator("bcc");

while ($it->hasNext())

{

$it->next();

$address = $it->getValue();

if (!$has_bcc) $message->setBcc($address->build());

try {

$this->command("MAIL FROM: " . $message->getReturnPath(true), 250);

$this->command("RCPT TO: " . $address->build(true), 250);

$this->command("DATA", 354);

$data = $message->build();

while (false !== $bytes = $data->read())

$this->command($bytes, -1);

if ($log->hasLevel(Swift_Log::LOG_NETWORK)) $log->add("<MESSAGE DATA>", Swift_Log::COMMAND);

$this->command("\r\n.", 250);

$sent++;

} catch (Swift_BadResponseException $e) {

$failed++;

$send_event->addFailedRecipient($address->getAddress());

if ($log->hasLevel(Swift_Log::LOG_FAILURES)) $log->addfailedRecipient($address->getAddress());

$this->reset();

}

}

$total = count($to) + count($cc) + count($list->getBcc());

$send_event->setNumSent($sent);

$this->notifyListeners($send_event, "SendListener");

if (!$has_return_path) $message->setReturnPath("");

if (!$has_from) $message->setFrom("");

if (!$has_to) $message->setTo("");

if (!$has_reply_to) $message->setReplyTo(null);

if (!$has_cc) $message->setCc(null);

if (!$has_bcc) $message->setBcc(null);

if (!$has_message_id) $message->setId(null);

if ($log->hasLevel(Swift_Log::LOG_NETWORK)) $log->add("Message sent to " . $sent . "/" . $total . " recipients", Swift_Log::NORMAL);

return $sent;

}

/**

* Send a message to a batch of recipients.

* Unlike send() this method ignores Cc and Bcc recipients and does not reveal every recipients' address in the headers

* @param Swift_Message The message to send (leave out the recipient headers unless you are deliberately overriding them)

* @param Swift_RecipientList The addresses to send to

* @param Swift_Address The address the mail is from (sender)

* @return int The number of successful recipients

*/

public function batchSend(Swift_Message $message, Swift_RecipientList $to, $from)

{

$batch = new Swift_BatchMailer($this);

return $batch->send($message, $to, $from);

}

}

<?php

/**

* EasySwift: Swift Mailer Facade

* Please read the LICENSE file

* @author Chris Corbyn <chris@w3style.co.uk>

* @package EasySwift

* @version 1.0.3

* @license GNU Lesser General Public License

*/

require_once dirname(__FILE__) . "/Swift/ClassLoader.php";

Swift_ClassLoader::load("Swift");

Swift_ClassLoader::load("Swift_Connection_SMTP");

Swift_ClassLoader::load("Swift_Connection_Sendmail");

//Some constants for backwards compatibility with v2 code

if (!defined("SWIFT_TLS")) define("SWIFT_TLS", Swift_Connection_SMTP::ENC_TLS);

if (!defined("SWIFT_SSL")) define("SWIFT_SSL", Swift_Connection_SMTP::ENC_SSL);

if (!defined("SWIFT_OPEN")) define("SWIFT_OPEN", Swift_Connection_SMTP::ENC_OFF);

if (!defined("SWIFT_SECURE_PORT")) define("SWIFT_SECURE_PORT", Swift_Connection_SMTP::PORT_SECURE);

if (!defined("SWIFT_DEFAULT_PORT")) define("SWIFT_DEFAULT_PORT", Swift_Connection_SMTP::PORT_DEFAULT);

/**

* EasySwift: Facade for Swift Mailer Version 3.

* Provides (most of) the API from older versions of Swift, wrapped around the new version 3 API.

* Due to the popularity of the new API, EasySwift will not be around indefinitely.

* @package EasySwift

* @author Chris Corbyn <chris@w3style.co.uk>

* @deprecated

*/

class EasySwift

{

/**

* The instance of Swift this class wrappers

* @var Swift

*/

public $swift = null;

/**

* This value becomes set to true when Swift fails

* @var boolean

*/

public $failed = false;

/**

* The number of loaded plugins

* @var int

*/

protected $pluginCount = 0;

/**

* An instance of Swift_Message

* @var Swift_Message

*/

public $message = null;

/**

* An address list to send to (Cc, Bcc, To..)

* @var Swift_RecipientList

*/

public $recipients = null;

/**

* If all recipients should get the same copy of the message, including headers

* This is already implied if any Cc or Bcc recipients are set

* @var boolean

*/

protected $exactCopy = false;

/**

* If EasySwift should get rid of the message and recipients once it's done sending

* @var boolean

*/

protected $autoFlush = true;

/**

* A list of the IDs of all parts added to the message

* @var array

*/

protected $partIds = array();

/**

* A list of all the IDs of the attachments add to the message

* @var array

*/

protected $attachmentIds = array();

/**

* The last response received from the server

* @var string

*/

public $lastResponse = "";

/**

* The 3 digit code in the last response received from the server

* @var int

*/

public $responseCode = 0;

/**

* The list of errors handled at runtime

* @var array

*/

public $errors = array();

/**

* The last error received

* @var string

*/

public $lastError = null;

/**

* Constructor

* @param Swift_Connection The connection to use

* @param string The domain name of this server (not the SMTP server)

*/

public function __construct(Swift_Connection $connection, $domain=null)

{

try {

$this->swift = new Swift($connection, $domain, Swift::ENABLE_LOGGING);

Swift_ClassLoader::load("Swift_Plugin_EasySwiftResponseTracker");

$this->swift->attachPlugin(new Swift_Plugin_EasySwiftResponseTracker($this), "_ResponseTracker");

} catch (Swift_ConnectionException $e) {

$this->failed = true;

$this->setError("The connection failed to start. An exception was thrown:<br />" . $e->getMessage());

}

$this->newMessage();

$this->newRecipientList();

}

/**

* Set an error message

* @param string Error message

*/

public function setError($msg)

{

$this->errors[] = ($this->lastError = $msg);

}

/**

* Get the full list of errors

* @return array

*/

public function getErrors()

{

return $this->errors;

}

/**

* Get the last error that occured

* @return string

*/

public function getLastError()

{

return $this->lastError;

}

/**

* Clear the current list of errors

*/

public function flushErrors()

{

$this->errors = null;

$this->errors = array();

}

/**

* Turn automatic flsuhing on or off.

* This in ON by deault. It removes the message and all parts after sending.

* @param boolean

*/

public function autoFlush($flush=true)

{

$this->autoFlush = $flush;

}

/**

* Set the maximum size of the log

* @param int

*/

public function setMaxLogSize($size)

{

$log = Swift_LogContainer::getLog();

$log->setMaxSize($size);

}

/**

* Turn logging on or off (saves memory)

* @param boolean

*/

public function useLogging($use=true)

{

$log = Swift_LogContainer::getLog();

if ($use) $log->setLogLevel(Swift_Log::LOG_NETWORK);

else $log->setLogLevel(Swift_Log::LOG_NOTHING);

}

/**

* Enable line resizing (on 1000 by default)

* @param int The number of characters allowed on a line

*/

public function useAutoLineResizing($size=1000)

{

$this->message->setLineWrap($size);

}

/**

* Dump the log contents

* @deprecated

*/

public function getTransactions()

{

return $this->dumpLog();

}

/**

* Dump the contents of the log to the browser

* The log contains some &lt; and &gt; characters so you may need to view source

* Note that this method dumps data to the browser, it does NOT return anything.

*/

public function dumpLog()

{

$log = Swift_LogContainer::getLog();

$log->dump();

}

/**

* This method should be called if you do not wish to send messages in batch mode (i.e. if all recipients should see each others' addresses)

* @param boolean If this mode should be used

*/

public function useExactCopy($bool=true)

{

$this->exactCopy = $bool;

}

/**

* Reset the current message and start a fresh one

*/

public function newMessage($msg=false)

{

if (!$msg) $msg = new Swift_Message();

$this->message = $msg;

$this->partIds = array();

$this->attachmentIds = array();

}

/**

* Clear out all message parts

* @return boolean

*/

public function flushParts()

{

$success = true;

foreach ($this->partIds as $id)

{

try {

$this->message->detach($id);

} catch (Swift_Message_MimeException $e) {

$success = false;

$this->setError("A MIME part failed to detach due to the error:<br />" . $e->getMessage());

}

}

$this->partIds = array();

return $success;

}

/**

* Clear out all attachments

* @return boolean

*/

public function flushAttachments()

{

$success = true;

foreach ($this->attachmentIds as $id)

{

try {

$this->message->detach($id);

} catch (Swift_Message_MimeException $e) {

$success = false;

$this->setError("An attachment failed to detach due to the error:<br />" . $e->getMessage());

}

}

$this->attachmentIds = array();

return $success;

}

/**

* Clear out all message headers

* @deprecated

*/

public function flushHeaders()

{

$this->newMessage();

}

/**

* Reset the current list of recipients and start a new one

*/

public function newRecipientList($list=false)

{

if (!$list) $list = new Swift_RecipientList();

$this->recipients = $list;

}

/**

* Check if Swift has failed or not

* This facade stops processing if so

* @return boolean

*/

public function hasFailed()

{

return $this->failed;

}

/**

* Check if the current connection is open or not

* @return boolean

*/

public function isConnected()

{

return (($this->swift !== null) && $this->swift->connection->isAlive());

}

/**

* Connect to the MTA if not already connected

*/

public function connect()

{

if (!$this->isConnected())

{

try {

$this->swift->connect();

return true;

} catch (Swift_ConnectionException $e) {

$this->failed = true;

$this->setError("Swift failed to run the connection process:<br />" . $e->getMessage());

}

}

return false;

}

/**

* Perform the SMTP greeting process (don't do this unless you understand why you're doing it)

*/

public function handshake()

{

$this->swift->handshake();

}

/**

* Close the connection to the MTA

* @return boolean

*/

public function close()

{

if ($this->isConnected())

{

try {

$this->swift->disconnect();

return true;

} catch (Swift_ConnectionException $e) {

$this->setError("Disconnect failed:<br />" . $e->getMessage());

}

}

return false;

}

/**

* Send a command to Swift and get a response

* @param string The command to send (leave of CRLF)

* @return string

*/

public function command($command)

{

if (substr($command, -2) == "\r\n") $command = substr($command, 0, -2);

try {

$rs = $this->swift->command($command);

return $rs->getString();

} catch (Swift_ConnectionException $e) {

$this->setError("Command failed:<br />" . $e->getMessage());

return false;

}

}

/**

* Add a new plugin to respond to events

* @param Swift_Events_Listener The plugin to load

* @param string The ID to identify the plugin by if needed

* @return string The ID of the plugin

*/

public function loadPlugin(Swift_Events_Listener $plugin, $name=null)

{

$this->pluginCount++;

if (!$name) $name = "p" . $this->pluginCount;

$this->swift->attachPlugin($plugin, $name);

return $name;

}

/**

* Get a reference to the plugin identified by $name

* @param string the ID of the plugin

* @return Swift_Events_Listener

*/

public function getPlugin($name)

{

try {

$plugin = $this->swift->getPlugin($name);

return $plugin;

} catch (Exception $e) {

return null;

}

}

/**

* Remove the plugin identified by $name

* @param string The ID of the plugin

* @return boolean

*/

public function removePlugin($name)

{

try {

$this->swift->removePlugin($name);

return true;

} catch (Exception $e) {

return false;

}

}

/**

* Load in a new authentication mechanism for SMTP

* This needn't be called since Swift will locate any available in Swift/Authenticator/*.php

* @param Swift_Authenticator The authentication mechanism to load

* @throws Exception If the wrong connection is used

*/

public function loadAuthenticator(Swift_Authenticator $auth)

{

if (method_exists($this->swift->connection, "attachAuthenticator"))

{

$this->swift->connection->attachAuthenticator($auth);

}

else throw new Exception("SMTP authentication cannot be used with connection class '" . get_class($this->connection) . "'. Swift_Connection_SMTP is needed");

}

/**

* Authenticate with SMTP authentication

* @param string The SMTP username

* @param string The SMTP password

* @return boolean

* @throws Exception If the wrong connection is used

*/

public function authenticate($username, $password)

{

if (method_exists($this->swift->connection, "runAuthenticators"))

{

try {

$this->swift->connection->runAuthenticators($username, $password, $this->swift);

return true;

} catch (Swift_ConnectionException $e) {

$this->setError("Authentication failed:<br />" . $e->getMessage());

return false;

}

}

else throw new Exception("SMTP authentication cannot be used with connection class '" . get_class($this->connection) . "'. Swift_Connection_SMTP is needed");

}

/**

* Turn a string representation of an email address into a Swift_Address object

* @paramm string The email address

* @return Swift_Address

*/

public function stringToAddress($string)

{

$name = null;

$address = null;

// Foo Bar <foo@bar>

// or: "Foo Bar" <foo@bar>

// or: <foo@bar>

Swift_ClassLoader::load("Swift_Message_Encoder");

if (preg_match("/^\\s*(\"?)(.*?)\\1 *<(" . Swift_Message_Encoder::CHEAP_ADDRESS_RE . ")>\\s*\$/", $string, $matches))

{

if (!empty($matches[2])) $name = $matches[2];

$address = $matches[3];

}

elseif (preg_match("/^\\s*" . Swift_Message_Encoder::CHEAP_ADDRESS_RE . "\\s*\$/", $string))

{

$address = trim($string);

}

else return false;

$swift_address = new Swift_Address($address, $name);

return $swift_address;

}

/**

* Set the encoding used in the message header

* The encoding can be one of Q (quoted-printable) or B (base64)

* @param string The encoding to use

*/

public function setHeaderEncoding($mode="B")

{

switch (strtoupper($mode))

{

case "Q": case "QP": case "QUOTED-PRINTABLE":

$this->message->headers->setEncoding("Q");

break;

default:

$this->message->headers->setEncoding("B");

}

}

/**

* Set the return path address (where bounces go to)

* @param mixed The address as a string or Swift_Address

*/

public function setReturnPath($address)

{

return $this->message->setReturnPath($address);

}

/**

* Request for a read recipient to be sent to the reply-to address

* @param boolean

*/

public function requestReadReceipt($request=true)

{

//$this->message->requestReadReceipt(true);

}

/**

* Set the message priority

* This is an integer between 1 (high) and 5 (low)

* @param int The level of priority to use

*/

public function setPriority($priority)

{

$this->message->setPriority($priority);

}

/**

* Get the return-path address as a string

* @return string

*/

public function getReturnPath()

{

try {

return $this->message->getReturnPath();

} catch (Swift_Message_MimeException $e) {

return false;

}

}

/**

* Set the reply-to header

* @param mixed The address replies come to. String, or Swift_Address, or an array of either.

*/

public function setReplyTo($address)

{

return $this->message->setReplyTo($address);

}

/**

* Get the reply-to address(es) as an array of strings

* @return array

*/

public function getReplyTo()

{

try {

return $this->message->getReplyTo();

} catch (Swift_Message_MimeException $e) {

return false;

}

}

/**

* Add To: recipients to the email

* @param mixed To address(es)

* @return boolean

*/

public function addTo($address)

{

return $this->addRecipients($address, "To");

}

/**

* Get an array of To addresses

* This currently returns an array of Swift_Address objects and may be simplified to an array of strings in later versions

* @return array

*/

public function getToAddresses()

{

return $this->recipients->getTo();

}

/**

* Clear out all To: recipients

*/

public function flushTo()

{

$this->recipients->flushTo();

}

/**

* Add Cc: recipients to the email

* @param mixed Cc address(es)

* @return boolean

*/

public function addCc($address)

{

return $this->addRecipients($address, "Cc");

}

/**

* Get an array of Cc addresses

* This currently returns an array of Swift_Address objects and may be simplified to an array of strings in later versions

* @return array

*/

public function getCcAddresses()

{

return $this->recipients->getCc();

}

/**

* Clear out all Cc: recipients

*/

public function flushCc()

{

$this->recipients->flushCc();

}

/**

* Add Bcc: recipients to the email

* @param mixed Bcc address(es)

* @return boolean

*/

public function addBcc($address)

{

return $this->addRecipients($address, "Bcc");

}

/**

* Get an array of Bcc addresses

* This currently returns an array of Swift_Address objects and may be simplified to an array of strings in later versions

* @return array

*/

public function getBccAddresses()

{

return $this->recipients->getBcc();

}

/**

* Clear out all Bcc: recipients

*/

public function flushBcc()

{

$this->recipients->flushBcc();

}

/**

* Add recipients to the email

* @param mixed Address(es)

* @param string Recipient type (To, Cc, Bcc)

* @return boolean

*/

protected function addRecipients($address, $type)

{

if (!in_array($type, array("To", "Cc", "Bcc"))) return false;

$method = "add" . $type;

if ($address instanceof Swift_Address)

{

$this->recipients->$method($address);

return true;

}

else

{

$added = 0;

foreach ((array)$address as $addr)

{

if (is_array($addr))

{

$addr = array_values($addr);

if (count($addr) >= 2)

{

$this->recipients->$method($addr[0], $addr[1]);

$added++;

continue;

}

elseif (count($addr) == 1) $addr = $addr[0];

else continue;

}

if (is_string($addr))

{

$addr = $this->stringToAddress($addr);

$this->recipients->$method($addr);

$added++;

}

}

return ($added > 0);

}

}

/**

* Flush message, recipients and headers

*/

public function flush()

{

$this->newMessage();

$this->newRecipientList();

}

/**

* Get a list of any addresses which have failed since instantiation

* @return array

*/

public function getFailedRecipients()

{

$log = Swift_LogContainer::getLog();

return $log->getFailedRecipients();

}

/**

* Set the multipart MIME warning message (only seen by old clients)

* @param string The message to show

*/

public function setMimeWarning($text)

{

$this->message->setMimeWarning($text);

}

/**

* Get the currently set MIME warning (seen by old clients)

* @return string

*/

public function getMimeWarning()

{

return $this->message->getMimeWarning();

}

/**

* Set the charset of the charset to use in the message

* @param string The charset (e.g. utf-8, iso-8859-1 etc)

* @return boolean

*/

public function setCharset($charset)

{

try {

$this->message->setCharset($charset);

return true;

} catch (Swift_Message_MimeException $e) {

$this->setError("Unable to set the message charset:<br />" . $e->getMessage());

return false;

}

}

/**

* Get the charset of the charset to use in the message

* @return string

*/

public function getCharset()

{

return $this->message->getCharset();

}

/**

* Add a new MIME part to the message

* @param mixed The part to add. If this is a string it's used as the body. If it's an instance of Swift_Message_Part it's used as the entire part

* @param string Content-type, default text/plain

* @param string The encoding used (default is to let Swift decide)

* @param string The charset to use (default is to let swift decide)

*/

public function addPart($body, $type="text/plain", $encoding=null, $charset=null)

{

if ($body instanceof Swift_Message_Mime)

{

try {

$this->partIds[] = $this->message->attach($body);

} catch (Swift_Message_MimeException $e) {

$this->setError("A MIME part failed to attach:<br />" . $e->getMessage());

return false;

}

}

else

{

try {

$this->partIds[] = $this->message->attach(new Swift_Message_Part($body, $type, $encoding, $charset));

} catch (Swift_Message_MimeException $e) {

$this->setError("A MIME part failed to attach:<br />" . $e->getMessage());

return false;

}

}

}

/**

* Add a new attachment to the message

* @param mixed The attachment to add. If this is a string it's used as the file contents. If it's an instance of Swift_Message_Attachment it's used as the entire part. If it's an instance of Swift_File it's used as the contents.

* @param string Filename, optional

* @param string Content-type. Default application/octet-stream

* @param string The encoding used (default is base64)

* @return boolean

*/

public function addAttachment($data, $filename=null, $type="application/octet-stream", $encoding=null)

{

if ($data instanceof Swift_Message_Mime)

{

try {

$this->attachmentIds[] = $this->message->attach($data);

} catch (Swift_Message_MimeException $e) {

$this->setError("An attachment failed to attach:<br />" . $e->getMessage());

return false;

}

}

else

{

try {

$this->attachmentIds[] = $this->message->attach(new Swift_Message_Attachment($data, $filename, $type, $encoding));

} catch (Swift_Message_MimeException $e) {

$this->setError("An attachment failed to attach<br />" . $e->getMessage());

return false;

} catch (Swift_FileException $e) {

$this->setError("An attachment failed to attach:<br />" . $e->getMessage());

return false;

}

}

return true;

}

/**

* Embed an image into the message and get the src attribute for HTML

* Returns FALSE on failure

* @param mixed The path to the image, a Swift_Message_Image object or a Swift_File object

* @return string

*/

public function addImage($input)

{

$ret = false;

if ($input instanceof Swift_Message_Image)

{

$ret = $this->message->attach($input);

$this->attachmentIds[] = $ret;

return $ret;

}

elseif ($input instanceof Swift_File)

{

try {

$ret = $this->message->attach(new Swift_Message_Image($input));

$this->attachmentIds[] = $ret;

return $ret;

} catch (Swift_Message_MimeException $e) {

$this->setError("An attachment failed to attach:<br />" . $e->getMessage());