if ($node->hasAttributes())  
          {
            foreach($node->attributes as $attr) 
            {
              if (in_array($attr->name, array('alt', 'title')) && trim($attr->value) != "") 
              {
                $strings[$template][] = $attr->value;
              }
            }
          }

      $result['meta']['Content-Type'] = 'text/plain; charset=utf-8';

/**
 * This class will use Symfony's logging system adding some ANSI color codes
 * depending on the severity/type of the message. The goal is to provide a quick
 * visual recognition of log lines on shell.
 *
 * TODO:
 * Actually do some inheritance here and extend Symonfy intself
 *
 * WARNING:
 * By using this class you will find some weird codes in the web debug interface.
 *
 * @author Guillermo Gutiérrez guille@nianoniano.com
 */
class Logger {
	// These are the log levels defined in Symfony
	const EMERG = 0; // System is unusable
	const ALERT = 1; // Immediate action required
	const CRIT = 2; // Critical conditions
	const ERR = 3; // Error conditions
	const WARNING = 4; // Warning conditions
	const NOTICE = 5; // Normal but significant
	const INFO = 6; // Informational
	const DEBUG = 7; // Debug-level messages
 
	const ANSI_END = "\033[0m";
 
	/**
	 * Adds a message to the log
	 *
	 * @param string $msg The message to be added
	 * @param string $module The module that is producing this message. Default: _DEBUG_
	 * @param string $severity The severity of the message. Must be one of the class constants
	 */
	public static function log($msg, $module = '_DEBUG_', $severity = self::DEBUG) {
		// I'm sure that there is a more elegant way to do this
		if (!in_array($severity, array(
			self::EMERG,
			self::ALERT,
			self::CRIT,
			self::ERR,
			self::WARNING,
			self::NOTICE,
			self::INFO,
			self::DEBUG
			))) {
			throw new Exception(__METHOD__ . " requires a valid severity code");
		}
		switch ($severity) {
			case self::EMERG:
			case self::ALERT:
				$style = "\033[0;49;31;1m";
				break;
			case self::CRIT:
			case self::ERR:
				$style = "\033[0;49;31m";
				break;
			case self::WARNING:
				$style = "\033[0;49;33;1m";
				break;
			case self::NOTICE:
			case self::INFO:
				$style = "\033[0;49;32m";
				break;
			case self::DEBUG:
				$style = "\033[0;49;36m";
				break;
		}
		$msg = $style."{".$module."} ".$msg.self::ANSI_END;
		try {
			sfContext::getInstance()->getLogger()->log($msg, $severity);
		} catch (Exception $e) {
			// Replace this with something else in production environments!
			echo $msg."\n";
		}
	}
 
	/**
	 * This method is a shortcut for self::log(print_r($someArray, true), $module, $severity);
	 * @param Array $array Array to be logged
	 * @param string $module The module that is producing this message. Default: _DEBUG_
	 * @param string $severity The severity of the message. Must be one of the class constants
	 */
	public static function printR($array, $module = '_DEBUG_', $severity = self::DEBUG) {
		self::log(print_r($array, true), $module, $severity);
	}
}

...
$ioParams = array(
	'proxy' => array(
		'ip' => sfConfig::get('curl_proxy_ip'),
		'port' => sfConfig::get('curl_proxy_port')
	),
	'userAgent' => true,
	'language' => $request->getParameter('language'),
	'due' => 30
);
$armory = new Armory(new IOCached($ioParams));
...

...
$ioParams = array(
	'proxy' => array(
		'ip' => sfConfig::get('curl_proxy_ip'),
		'port' => sfConfig::get('curl_proxy_port')
	),
	'userAgent' => true,
	'language' => $request->getParameter('language')
);
$armory = new Armory(new IO($ioParams));
...

/**
 * Input Output class
 *
 * This class implements an abstraction layer for curl HTTP calls
 *
 * TODO:
 *  - Change behavior of user agent configuration option to let the string itself to be set
 *  - Implement dependency injection for log and debug
 *
 * @author     Guillermo Gutiérrez guille@nianoniano.com
 */
class IO {
	/**
	 * Stores the description for connection errors using curl. Connection errors come from connection timeouts and DNS resolution errores from curl interaction with the remote host or the proxy
	 * @var string
	 */
	const IO_CONNECTION_ERROR = "Host/proxy resolutionor connection error";
	/**
	 * Stores the description for remote host error response codes
	 * @var string
	 */
	const IO_HOST_ERROR = "Received an error from the host";
	/**
	 * Stores the description for timeouts after connection is established
	 * @var string
	 */
	const IO_TIMEOUT = "Timeout error";
	/**
	 * Stores the description for a generic error
	 * @var string
	 */
	const IO_ERROR = "Generic error";
 
	/**
	 * Stores the User Agent string to be used in the HTTP headers if needed
	 * @var unknown_type
	 */
	const USER_AGENT = "Mozilla/5.0 (X11; U; Linux x86_64; es-ES; rv:1.9.0.8) Gecko/2009032712 Ubuntu/8.10 (intrepid) Firefox/3.0.8";
 
	/**
	 * Stores the IP for the proxy
	 * @var string with format: www.xxx.yyy.zzz
	 */
	protected $proxyIp;
	/**
	 * Stores the port number for the proxy
	 * @var integer
	 */
	protected $proxyPort;
	/**
	 * Stores a boolean flag to tell this instance if it has to include User Agent HTTP header or not
	 * @var boolean
	 */
	protected $userAgent;
	/**
	 * Stores the language for the communication
	 * @var string with 2 or 5 character code
	 */
	protected $language;
	/**
	 * Stores the maximum number of tries to be perfomed before giving up
	 * @var integer
	 */
	protected $maxTries;
	/**
	 * Stores the maximum number of seconds to wait for connection to the remote host or proxy before giving up
	 * @var integer
	 */
	protected $connectionTimeout;
	/**
	 * Stores the maximum number of seconds to wait for data before giving up
	 * @var integer
	 */
	protected $timeout;
 
	/**
	 * Class constructor. It may receive an array of optional configuration options:
	 *
	 *  - proxy: An array with IP and port indexes specifying the information to use a proxy for calls. Optional
	 *  - userAgent: Boolean that will tell the instance to use User Agent header in the calls or not. Default: true
	 *  - language: 2 or 5 character culture code. Default: es
	 *  - maxTries: Integer with the number of tries before throwing an IO_CONNECTION_ERROR exception. Default: 3
	 *  - connectionTimeout: Integer with the number of seconds to wait establishing the connection to the remote host before throwing an IO_CONNECTION_ERROR. Default: 5
	 *  - timeout: Integer with the number of seconds to wait for data from the remote host before throwing an IO_TIMEOUT. Default: 15
	 *
	 * @param $options array with options to be set
	 */
	public function __construct($options = array()) {
		if (array_key_exists('proxy', $options)) {
			$this->proxyIp = $options['proxy']['ip'];
			$this->proxyPort = $options['proxy']['port'];
		}
		if (array_key_exists('userAgent', $options)) {
			$this->userAgent = $options['userAgent'];
		} else {
			$this->userAgent = true;
		}
		if (array_key_exists('language', $options)) {
			$this->language = $options['language'];
		} else {
			$this->language = 'es';
		}
		if (array_key_exists('maxTries', $options)) {
			$this->maxTries = max(1, $options['maxTries']);
		} else {
			$this->maxTries = 3;
		}
		if (array_key_exists('connectionTimeout', $options)) {
			$this->connectionTimeout = max(1, $options['connectionTimeout']);
		} else {
			$this->connectionTimeout = 5;
		}
		if (array_key_exists('timeout', $options)) {
			$this->timeout = max(1, $options['timeout']);
		} else {
			$this->timeout = 15;
		}
	}
 
	/**
	 * Returns the language for this instance
	 */
	public function getLanguage() {
		return $this->language;
	}
 
	/**
	 * Returns the proxy's IP for this instance
	 */
	public function getProxyIp() {
		return $this->proxyIp;
	}
 
	/**
	 * Returns the proxy's port for this instance
	 */
	public function getProxyPort() {
		return $this->proxyPort;
	}
 
	/**
	 * Returns the user agent for this instance
	 */
	public function getUserAgent() {
		return $this->userAgent;
	}
 
	/**
	 * Sets the proxy's IP for this instance
	 *
	 * @param string $proxyIp with the IP to be used (xxx.xxx.xxx.xxx format)
	 */
	public function setProxyIp($proxyIp) {
		$this->proxyIp = $proxyIp;
	}
 
	/**
	 * Sets the proxy's port for this instance
	 *
	 * @param integer $proxyPort with the port number to be used
	 */
	public function setProxyPort($proxyPort) {
		$this->proxyPort = $proxyPort;
	}
 
	/**
	 * Sets the user agent for this instance
	 *
	 * @param bool $userAgent with a boolean that will decide if we use user agent header or not
	 */
	public function setUserAgent($userAgent) {
		$this->userAgent = $userAgent;
	}
 
	/**
	 * Sets the language for this instance
	 *
	 * @param string $language with the language (culture) to be used (2 or 5 character code)
	 */
	public function setLanguage($language) {
		$this->language = $language;
	}
 
	/**
	 * Performs a curl call to a given url, using the given method and post payload if it is present
	 *
	 * @param string $url with the url to be called
	 * @param string $method with the method to be used (get or post). Default: get
	 * @param string $postPayload (optional) with the post payload to be sent (for form simulation)
	 */
	public function call($url, $method = 'get', $postPayload = null) {
		$stop = false;
		$tries = 0;
		while(!$stop) {
			$tries++;
			Logger::log(vsprintf("Performing try #%s to %s", array($tries, $url)));
			$ch = curl_init($url);
			curl_setopt($ch, CURLOPT_TIMEOUT, $this->timeout);
			curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $this->connectionTimeout);
			curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
			curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
			curl_setopt($ch, CURLOPT_HTTPHEADER, array(sprintf('Accept-Language: %s', $this->language)));
			if ($method == 'post') {
				curl_setopt($ch, CURLOPT_POST, true);
				curl_setopt($ch, CURLOPT_POSTFIELDS, $postPayload);
			}
			if ($this->userAgent) {
				curl_setopt($ch, CURLOPT_USERAGENT, self::USER_AGENT);
			}
			if ($this->proxyIp != null && $this->proxyPort != null) {
				curl_setopt($ch, CURLOPT_PROXY, vsprintf("%s:%s", array($this->proxyIp, $this->proxyPort)));
			}
			$result = curl_exec($ch);
			switch(curl_errno($ch)) {
				case CURLE_OK:
					$stop = true;
					break;
				case CURLE_COULDNT_RESOLVE_PROXY:
				case CURLE_COULDNT_RESOLVE_HOST:
				case CURLE_COULDNT_CONNECT:
					Logger::log($url." => ".curl_error($ch), __METHOD__, Logger::CRIT);
					if ($tries == $this->maxTries) {
						throw new Exception(self::IO_CONNECTION_ERROR);
					}
					break;
				case CURLE_HTTP_RETURNED_ERROR:
					Logger::log($url." => ".curl_error($ch), __METHOD__, Logger::WARNING);
					if ($tries == $this->maxTries) {
						throw new Exception(self::IO_HOST_ERROR);
					}
					break;
				case CURLE_OPERATION_TIMEDOUT:
					Logger::log($url." => ".curl_error($ch), __METHOD__, Logger::WARNING);
					if ($tries == $this->maxTries) {
						throw new Exception(self::IO_TIMEOUT);
					}
					break;
				default:
					Logger::log($url." => ".curl_error($ch), __METHOD__, Logger::WARNING);
					throw new Exception(self::IO_ERROR);
					break;
			}
			$stop = ($stop || $tries == $this->maxTries);
		}
		curl_close($ch);
		return $result;
	}
 
	/**
	 * Prepares params to be added to a url for a get call
	 *
	 * @param mixed $params Array or string with params
	 */
	public static function prepareParams($params) {
		$newParams = "";
		if (is_array($params) && count($params) > 0) {
			foreach ($params as $name => $value) {
				$newParams .= "$name=$value&";
			}
			$newParams = substr($newParams, 0, -1);
		} else {
			$newParams .= trim($params);
		}
		return $newParams;
	}
}

/**
 * Input Output class, cached flavour
 *
 * This class is used to abstract curl calls and implements a cache layer to economize network usage
 *
 * TODO:
 *  - Adapt log and debug when it's implemented in IO
 *
 * @author     Guillermo Gutiérrez guille@nianoniano.com
 */
class IOCached extends IO {
	protected $due;
 
	/**
	 * Class constructor. It may receive an array of optional configuration options:
	 *
	 *  - due: Integer with the timestamp for the date and time that the cache will due for the calls this instance will perform
	 *  - and everyone defined in IO class
	 *
	 * @param $options array with options to be set
	 * @see IO
	 */
	public function __construct($options = array()) {
		parent::__construct($options);
		if (array_key_exists('due', $options)) {
			$this->due = $options['due'];
		} else {
			throw new Exception(__CLASS__." constructor needs a 'due' option to be set");
		}
	}
 
	/**
	 * Performs a curl call to a given url, using the given method and post payload if it is present
	 *
	 * @param string $url with the url to be called
	 * @param string $method with the method to be used (get or post). Default: get
	 * @param string $postPayload (optional) with the post payload to be sent (for form simulation)
	 */
	public function call($url, $method = 'get', $postPayload = null) {
		$postPayload = IO::prepareParams($postPayload);
		$hash = $this->getHash($url, $postPayload);
		$ioCache = IoCachePeer::retrieveByPK($hash);
		/* @var ioCache IoCache */
		if (!($ioCache instanceof IoCache)) {
			Logger::log("Creating cache for {".$method."} $url", __METHOD__, Logger::INFO);
			$ioCache = new IoCache();
			$ioCache->setHash($hash);
			$ioCache->setInfo(vsprintf(
				"{%s} %s (%s) - User Agent: %s",
				array(
					$method,
					$url,
					($postPayload != "") ? $postPayload : "no payload",
					($this->getUserAgent()) ? "ON" : "OFF"
				)
			));
		} else {
			Logger::log("Found cache for {".$method."} $url", __METHOD__, Logger::INFO);
		}
		if ($ioCache->getTs('U') < (time() - $this->due)) {
			$ioCache->setContent(parent::call($url, $method, $postPayload));
			$ioCache->setTs(time());
			$ioCache->save();
			Logger::log("Cache updated with fresh content", __METHOD__, Logger::INFO);
 
		}
		return $ioCache->getContent();
	}
 
	/**
	 * Returns the calculated hash that identifies the given url and param string pair
	 *
	 * @param $url string
	 * @param $params string
	 */
	private function getHash($url, $params) {
		return sha1($this->getUserAgent().$url.$params);
	}
}

CREATE TABLE  `tdg_delta`.`io_cache` (
  `hash` varchar(255) NOT NULL,
  `info` varchar(255) NOT NULL,
  `ts` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  `content` longtext,
  PRIMARY KEY  (`hash`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

class Armory {
	protected $io;
 
	public function __construct($io) {
		$this->io = $io;
	}
 
	public function searchItems($name) {
		$url = sfConfig::get('armory_eu_url') . "/" . sprintf(sfConfig::get('armory_query_search_item'), $name);
		$data = new SimpleXMLElement($this->io->call($url));
		$itemXMLList = $data->xpath('//item');
		$itemList = array();
		foreach ($itemXMLList as $itemXML) {
			$item = array();
			$item['id'] = (int)$itemXML['id'];
			$item['name'] = (string)$itemXML['name'];
			$item['rarity'] = (int)$itemXML['rarity'];
			$item['icon'] = (string)$itemXML['icon'];
			$itemList[] = $item;
			self::getArmoryIcon($item['icon']);
		}
		return array_slice($itemList, 0, 25);
	}
 
	public static function getArmoryIcon($image) {
		$localPath = sfConfig::get('sf_root_dir') . "/web" . sfConfig::get('armory_icon_local_path') . "/$image.png";
		if (!file_exists($localPath)) {
			$remotePath = sfConfig::get('armory_eu_url') . sfConfig::get('armory_icon_remote_path') . "/$image.png";
			$io = new IO(array('proxy' => array('ip' => sfConfig::get('curl_proxy_ip'), 'port' => sfConfig::get('curl_proxy_port'))));
			file_put_contents($localPath, $io->call($remotePath));
		}
	}
 
	public function searchChars($name, $wowServerGroupId = 1) {
		if (trim($name) == "") {
			$name = "Donald";
		}
 
		$wowServerGroup = WowServerGroupPeer::retrieveByPK($wowServerGroupId);
		if (!($wowServerGroup instanceof WowServerGroup)) {
			Logger::log("Received server group doesn't exist", __METHOD__, Logger::CRIT);
			throw new Exception("Wrong server group selected");
		}
 
		// Get content from armory
		$url = $wowServerGroup->getArmoryUrl()."/".sprintf(sfConfig::get('armory_query_search_char'), $name);
		$data = new SimpleXMLElement($this->io->call($url));
		$characterXMLList = $data->xpath('//character');
 
		// Realms and guilds
		$criteria = new Criteria();
		$wowRealms = array();
		foreach($wowServerGroup->getWowRealms($criteria) as $wowRealm) {
			$wowRealms[$wowRealm->getName()] = $wowRealm;
		}
		$wowGuilds = WowGuildPeer::doSelectIndexedByPK($criteria);
 
		// Parse chars
		$wowChars = array();
		foreach($characterXMLList as $char) {
			$wowChar = new WowChar();
			$wowChar->setWowClassId((int)$char['classId']);
			$wowChar->setWowGenderId((int)$char['genderId']);
			if (!array_key_exists((string)$char['realm'], $wowRealms)) {
				$wowRealm = new WowRealm();
				$wowRealm->setName((string)$char['realm']);
				$wowRealm->setWowServerGroupId($wowServerGroup->getWowServerGroupId());
				$wowRealm->save();
				$wowRealms[$wowRealm->getName()] = $wowRealm;
			}
			if ((int)$char['guildId'] != 0) {
				if (!array_key_exists((int)$char['guildId'], $wowGuilds)) {
					$wowGuild = new WowGuild();
					$wowGuild->setWowGuildId((int)$char['guildId']);
					$wowGuild->setName((string)$char['guild']);
					$wowGuild->setWowRealmId($wowRealms[(string)$char['realm']]);
					$wowGuild->save();
					$wowGuilds[$wowGuild->getWowGuildId()] = $wowGuild;
				}
				$wowChar->setWowGuildId((int)$char['guildId']);
			}
			$wowChar->setWowRealmId($wowRealms[(string)$char['realm']]->getWowRealmId());
			$wowChar->setLevel((int)$char['level']);
			$wowChar->setName((string)$char['name']);
			$wowChar->setWowRaceId((int)$char['raceId']);
			$wowChars[] = $wowChar;
		}
		return $wowChars;
	}
 
}