powerdlz23 1.1.6 → 1.1.8

package/pto/yaamp/web/framework-1.0.8/web/services/CWsdlGenerator.php

@@ -0,0 +1,373 @@
+<?php
+/**
+ * CWsdlGenerator class file.
+ *
+ * @author Qiang Xue <qiang.xue@gmail.com>
+ * @link http://www.yiiframework.com/
+ * @copyright Copyright &copy; 2008-2009 Yii Software LLC
+ * @license http://www.yiiframework.com/license/
+ */
+
+/**
+ * CWsdlGenerator generates the WSDL for a given service class.
+ *
+ * The WSDL generation is based on the doc comments found in the service class file.
+ * In particular, it recognizes the '@soap' tag in the comment and extracts
+ * API method and type definitions.
+ *
+ * In a service class, a remote invokable method must be a public method with a doc
+ * comment block containing the '@soap' tag. In the doc comment, the type and name
+ * of every input parameter and the type of the return value should be declared using
+ * the standard phpdoc format.
+ *
+ * CWsdlGenerator recognizes the following primitive types (case-sensitive) in
+ * the parameter and return type declarations:
+ * <ul>
+ * <li>str/string: maps to xsd:string;</li>
+ * <li>int/integer: maps to xsd:int;</li>
+ * <li>float/double: maps to xsd:float;</li>
+ * <li>bool/boolean: maps to xsd:boolean;</li>
+ * <li>date: maps to xsd:date;</li>
+ * <li>time: maps to xsd:time;</li>
+ * <li>datetime: maps to xsd:dateTime;</li>
+ * <li>array: maps to xsd:string;</li>
+ * <li>object: maps to xsd:struct;</li>
+ * <li>mixed: maps to xsd:anyType.</li>
+ * </ul>
+ *
+ * If a type is not a primitive type, it is considered as a class type, and
+ * CWsdlGenerator will look for its property declarations. Only public properties
+ * are considered, and they each must be associated with a doc comment block containg
+ * the '@soap' tag. The doc comment block should declare the type of the property.
+ *
+ * CWsdlGenerator recognizes the array type with the following format:
+ * <pre>
+ * typeName[]: maps to tns:typeNameArray
+ * </pre>
+ *
+ * The following is an example declaring a remote invokable method:
+ * <pre>
+ * / **
+ *   * A foo method.
+ *   * @param string name of something
+ *   * @param string value of something
+ *   * @return string[] some array
+ *   * @soap
+ *   * /
+ * public function foo($name,$value) {...}
+ * </pre>
+ *
+ * And the following is an example declaring a class with remote accessible properties:
+ * <pre>
+ * class Foo {
+ *     / **
+ *       * @var string name of foo
+ *       * @soap
+ *       * /
+ *     public $name;
+ *     / **
+ *       * @var Member[] members of foo
+ *       * @soap
+ *       * /
+ *     public $members;
+ * }
+ * </pre>
+ * In the above, the 'members' property is an array of 'Member' objects. Since 'Member' is not
+ * a primitive type, CWsdlGenerator will look further to find the definition of 'Member'.
+ *
+ * @author Qiang Xue <qiang.xue@gmail.com>
+ * @version $Id: CWsdlGenerator.php 1066 2009-05-26 15:23:48Z qiang.xue $
+ * @package system.web.services
+ * @since 1.0
+ */
+class CWsdlGenerator extends CComponent
+{
+	private $_operations;
+	private $_types;
+	private $_messages;
+	private $_namespace;
+	private $_serviceName;
+
+	/**
+	 * Generates the WSDL for the given class.
+	 * @param string class name
+	 * @param string Web service URL
+	 * @param string encoding of the WSDL. Defaults to 'UTF-8'.
+	 * @return string the generated WSDL
+	 */
+	public function generateWsdl($className, $serviceUrl, $encoding='UTF-8')
+	{
+		$this->_operations=array();
+		$this->_types=array();
+		$this->_messages=array();
+		$this->_serviceName=$className;
+		$this->_namespace="urn:{$className}wsdl";
+
+		$reflection=new ReflectionClass($className);
+		foreach($reflection->getMethods() as $method)
+		{
+			if($method->isPublic())
+				$this->processMethod($method);
+		}
+
+		return $this->buildDOM($serviceUrl,$encoding)->saveXML();
+	}
+
+	private function processMethod($method)
+	{
+		$comment=$method->getDocComment();
+		if(strpos($comment,'@soap')===false)
+			return;
+
+		$methodName=$method->getName();
+		$comment=preg_replace('/^\s*\**(\s*?$|\s*)/m','',$comment);
+		$params=$method->getParameters();
+		$message=array();
+		$n=preg_match_all('/^@param\s+([\w\.]+(\[\s*\])?)\s*?(.*)$/im',$comment,$matches);
+		if($n>count($params))
+			$n=count($params);
+		for($i=0;$i<$n;++$i)
+			$message[$params[$i]->getName()]=array($this->processType($matches[1][$i]), trim($matches[3][$i])); // name => type, doc
+
+		$this->_messages[$methodName.'Request']=$message;
+
+		if(preg_match('/^@return\s+([\w\.]+(\[\s*\])?)\s*?(.*)$/im',$comment,$matches))
+			$return=array($this->processType($matches[1]),trim($matches[2])); // type, doc
+		else
+			$return=null;
+		$this->_messages[$methodName.'Response']=array('return'=>$return);
+
+		if(preg_match('/^\/\*+\s*([^@]*?)\n@/s',$comment,$matches))
+			$doc=trim($matches[1]);
+		else
+			$doc='';
+		$this->_operations[$methodName]=$doc;
+	}
+
+	private function processType($type)
+	{
+		static $typeMap=array(
+			'string'=>'xsd:string',
+			'str'=>'xsd:string',
+			'int'=>'xsd:int',
+			'integer'=>'xsd:integer',
+			'float'=>'xsd:float',
+			'double'=>'xsd:float',
+			'bool'=>'xsd:boolean',
+			'boolean'=>'xsd:boolean',
+			'date'=>'xsd:date',
+			'time'=>'xsd:time',
+			'datetime'=>'xsd:dateTime',
+			'array'=>'soap-enc:Array',
+			'object'=>'xsd:struct',
+			'mixed'=>'xsd:anyType',
+		);
+		if(isset($typeMap[$type]))
+			return $typeMap[$type];
+		else if(isset($this->_types[$type]))
+			return is_array($this->_types[$type]) ? 'tns:'.$type : $this->_types[$type];
+		else if(($pos=strpos($type,'[]'))!==false) // if it is an array
+		{
+			$type=substr($type,0,$pos);
+			if(isset($typeMap[$type]))
+				$this->_types[$type.'[]']='xsd:'.$type.'Array';
+			else
+			{
+				$this->_types[$type.'[]']='tns:'.$type.'Array';
+				$this->processType($type);
+			}
+			return $this->_types[$type.'[]'];
+		}
+		else // class type
+		{
+			$type=Yii::import($type,true);
+			$this->_types[$type]=array();
+			$class=new ReflectionClass($type);
+			foreach($class->getProperties() as $property)
+			{
+				$comment=$property->getDocComment();
+				if($property->isPublic() && strpos($comment,'@soap')!==false)
+				{
+					if(preg_match('/@var\s+([\w\.]+(\[\s*\])?)\s*?(.*)$/mi',$comment,$matches))
+						$this->_types[$type][$property->getName()]=array($this->processType($matches[1]),trim($matches[3]));  // name => type, doc
+				}
+			}
+			return 'tns:'.$type;
+		}
+	}
+
+	private function buildDOM($serviceUrl,$encoding)
+	{
+		$xml="<?xml version=\"1.0\" encoding=\"$encoding\"?>
+<definitions name=\"{$this->_serviceName}\" targetNamespace=\"{$this->_namespace}\"
+     xmlns=\"http://schemas.xmlsoap.org/wsdl/\"
+     xmlns:tns=\"{$this->_namespace}\"
+     xmlns:soap=\"http://schemas.xmlsoap.org/wsdl/soap/\"
+     xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"
+	 xmlns:wsdl=\"http://schemas.xmlsoap.org/wsdl/\"
+     xmlns:soap-enc=\"http://schemas.xmlsoap.org/soap/encoding/\"></definitions>";
+
+		$dom=new DOMDocument();
+		$dom->loadXml($xml);
+		$this->addTypes($dom);
+
+		$this->addMessages($dom);
+		$this->addPortTypes($dom);
+		$this->addBindings($dom);
+		$this->addService($dom,$serviceUrl);
+
+		return $dom;
+	}
+
+	private function addTypes($dom)
+	{
+		if($this->_types===array())
+			return;
+		$types=$dom->createElement('wsdl:types');
+		$schema=$dom->createElement('xsd:schema');
+		$schema->setAttribute('targetNamespace',$this->_namespace);
+		foreach($this->_types as $phpType=>$xmlType)
+		{
+			if(is_string($xmlType) && strrpos($xmlType,'Array')!==strlen($xmlType)-5)
+				continue;  // simple type
+			$complexType=$dom->createElement('xsd:complexType');
+			if(is_string($xmlType))
+			{
+				if(($pos=strpos($xmlType,'tns:'))!==false)
+					$complexType->setAttribute('name',substr($xmlType,4));
+				else
+					$complexType->setAttribute('name',$xmlType);
+				$complexContent=$dom->createElement('xsd:complexContent');
+				$restriction=$dom->createElement('xsd:restriction');
+				$restriction->setAttribute('base','soap-enc:Array');
+				$attribute=$dom->createElement('xsd:attribute');
+				$attribute->setAttribute('ref','soap-enc:arrayType');
+				$attribute->setAttribute('wsdl:arrayType',substr($xmlType,0,strlen($xmlType)-5).'[]');
+				$restriction->appendChild($attribute);
+				$complexContent->appendChild($restriction);
+				$complexType->appendChild($complexContent);
+			}
+			else if(is_array($xmlType))
+			{
+				$complexType->setAttribute('name',$phpType);
+				$all=$dom->createElement('xsd:all');
+				foreach($xmlType as $name=>$type)
+				{
+					$element=$dom->createElement('xsd:element');
+					$element->setAttribute('name',$name);
+					$element->setAttribute('type',$type[0]);
+					$all->appendChild($element);
+				}
+				$complexType->appendChild($all);
+			}
+			$schema->appendChild($complexType);
+			$types->appendChild($schema);
+		}
+
+		$dom->documentElement->appendChild($types);
+	}
+
+	private function addMessages($dom)
+	{
+		foreach($this->_messages as $name=>$message)
+		{
+			$element=$dom->createElement('wsdl:message');
+			$element->setAttribute('name',$name);
+			foreach($this->_messages[$name] as $partName=>$part)
+			{
+				if(is_array($part))
+				{
+					$partElement=$dom->createElement('wsdl:part');
+					$partElement->setAttribute('name',$partName);
+					$partElement->setAttribute('type',$part[0]);
+					$element->appendChild($partElement);
+				}
+			}
+			$dom->documentElement->appendChild($element);
+		}
+	}
+
+	private function addPortTypes($dom)
+	{
+		$portType=$dom->createElement('wsdl:portType');
+		$portType->setAttribute('name',$this->_serviceName.'PortType');
+		$dom->documentElement->appendChild($portType);
+		foreach($this->_operations as $name=>$doc)
+			$portType->appendChild($this->createPortElement($dom,$name,$doc));
+	}
+
+	private function createPortElement($dom,$name,$doc)
+	{
+		$operation=$dom->createElement('wsdl:operation');
+		$operation->setAttribute('name',$name);
+
+		$input = $dom->createElement('wsdl:input');
+		$input->setAttribute('message', 'tns:'.$name.'Request');
+		$output = $dom->createElement('wsdl:output');
+		$output->setAttribute('message', 'tns:'.$name.'Response');
+
+		$operation->appendChild($dom->createElement('wsdl:documentation',$doc));
+		$operation->appendChild($input);
+		$operation->appendChild($output);
+
+		return $operation;
+	}
+
+	private function addBindings($dom)
+	{
+		$binding=$dom->createElement('wsdl:binding');
+		$binding->setAttribute('name',$this->_serviceName.'Binding');
+		$binding->setAttribute('type','tns:'.$this->_serviceName.'PortType');
+
+		$soapBinding=$dom->createElement('soap:binding');
+		$soapBinding->setAttribute('style','rpc');
+		$soapBinding->setAttribute('transport','http://schemas.xmlsoap.org/soap/http');
+		$binding->appendChild($soapBinding);
+
+		$dom->documentElement->appendChild($binding);
+
+		foreach($this->_operations as $name=>$doc)
+			$binding->appendChild($this->createOperationElement($dom,$name));
+	}
+
+	private function createOperationElement($dom,$name)
+	{
+		$operation=$dom->createElement('wsdl:operation');
+		$operation->setAttribute('name', $name);
+		$soapOperation = $dom->createElement('soap:operation');
+		$soapOperation->setAttribute('soapAction', $this->_namespace.'#'.$name);
+		$soapOperation->setAttribute('style','rpc');
+
+		$input = $dom->createElement('wsdl:input');
+		$output = $dom->createElement('wsdl:output');
+
+		$soapBody = $dom->createElement('soap:body');
+		$soapBody->setAttribute('use', 'encoded');
+		$soapBody->setAttribute('namespace', $this->_namespace);
+		$soapBody->setAttribute('encodingStyle', 'http://schemas.xmlsoap.org/soap/encoding/');
+		$input->appendChild($soapBody);
+		$output->appendChild(clone $soapBody);
+
+		$operation->appendChild($soapOperation);
+		$operation->appendChild($input);
+		$operation->appendChild($output);
+
+		return $operation;
+	}
+
+	private function addService($dom,$serviceUrl)
+	{
+		$service=$dom->createElement('wsdl:service');
+		$service->setAttribute('name', $this->_serviceName.'Service');
+
+		$port=$dom->createElement('wsdl:port');
+		$port->setAttribute('name', $this->_serviceName.'Port');
+		$port->setAttribute('binding', 'tns:'.$this->_serviceName.'Binding');
+
+		$soapAddress=$dom->createElement('soap:address');
+		$soapAddress->setAttribute('location',$serviceUrl);
+		$port->appendChild($soapAddress);
+		$service->appendChild($port);
+		$dom->documentElement->appendChild($service);
+	}
+}

package/pto/yaamp/web/framework-1.0.8/web/widgets/CAutoComplete.php

@@ -0,0 +1,285 @@
+<?php
+/**
+ * CAutoComplete class file.
+ *
+ * @author Qiang Xue <qiang.xue@gmail.com>
+ * @link http://www.yiiframework.com/
+ * @copyright Copyright &copy; 2008-2009 Yii Software LLC
+ * @license http://www.yiiframework.com/license/
+ */
+
+/**
+ * CAutoComplete generates an auto-complete text field.
+ *
+ * CAutoComplete is based on the {@link http://plugins.jquery.com/project/autocompletex jQuery Autocomplete}.
+ *
+ * @author Qiang Xue <qiang.xue@gmail.com>
+ * @version $Id: CAutoComplete.php 913 2009-04-04 02:01:48Z qiang.xue $
+ * @package system.web.widgets
+ * @since 1.0
+ */
+class CAutoComplete extends CInputWidget
+{
+	/**
+	 * @var boolean whether to show the autocomplete using a text area. Defaults to false,
+	 * meaning a text field is used.
+	 * @since 1.0.4
+	 */
+	public $textArea=false;
+	/**
+	 * @var array data that would be saved as client-side data to provide candidate selections.
+	 * Each array element can be string or an associative array.
+	 * The {@link url} property will be ignored if this property is set.
+	 * @see url
+	 */
+	public $data;
+	/**
+	 * @var string|array the URL that can return the candidate selections.
+	 * A 'q' GET parameter will be sent with the URL which contains what the user has entered so far.
+	 * If the URL is given as an array, it is considered as a route to a controller action and will
+	 * be used to generate a URL using {@link CController::createUrl};
+	 * If the URL is an empty string, the currently requested URL is used.
+	 * This property will be ignored if {@link data} is set.
+	 * @see data
+ 	 */
+	public $url='';
+	/**
+	 * @var mixed the CSS file used for the widget. Defaults to null, meaning
+	 * using the default CSS file included together with the widget.
+	 * If false, no CSS file will be used. Otherwise, the specified CSS file
+	 * will be included when using this widget.
+	 */
+	public $cssFile;
+	/**
+	 * @var integer the minimum number of characters a user has to type before
+	 * the autocompleter activates. Defaults to 1.
+	 */
+	public $minChars;
+	/**
+	 * @var integer the delay in milliseconds the autocompleter waits after
+	 * a keystroke to activate itself. Defaults to 400.
+	 */
+	public $delay;
+	/**
+	 * @var integer the number of backend query results to store in cache.
+	 * If set to 1 (the current result), no caching will happen. Must be >= 1. Defaults to 10.
+	 */
+	public $cacheLength;
+	/**
+	 * @var boolean whether or not the autocompleter can use a cache for more
+	 * specific queries. This means that all matches of "foot" are a subset
+	 * of all matches for "foo". Usually this is true, and using this options
+	 * decreases server load and increases performance. Only useful with
+	 * cacheLength settings bigger than one, like 10. Defaults to true.
+	 */
+	public $matchSubset;
+	/**
+	 * @var boolean whether or not the comparison is case sensitive. Important
+	 * only if you use caching. Defaults to false.
+	 */
+	public $matchCase;
+	/**
+	 * @var boolean whether or not the comparison looks inside
+	 * (i.e. does "ba" match "foo bar") the search results. Important only if
+	 * you use caching. Don't mix with autofill. Defaults to false.
+	 */
+	public $matchContains;
+	/**
+	 * @var boolean if set to true, the autocompleter will only allow results that
+	 * are presented by the backend. Note that illegal values result in an empty
+	 * input box. Defaults to false.
+	 */
+	public $mustMatch;
+	/**
+	 * @var boolean if this is set to true, the first autocomplete value will
+	 * be automatically selected on tab/return, even if it has not been handpicked
+	 * by keyboard or mouse action. If there is a handpicked (highlighted) result,
+	 * that result will take precedence. Defaults to true.
+	 */
+	public $selectFirst;
+	/**
+	 * @var array extra parameters for the backend. If you were to specify
+	 * array('bar'=>4), the autocompleter would call the backend with a GET
+	 * parameter 'bar' 4. The param can be a function that is called to calculate
+	 * the param before each request.
+	 */
+	public $extraParams;
+	/**
+	 * @var string a javascript function that provides advanced markup for an item.
+	 * For each row of results, this function will be called. The returned value will
+	 * be displayed inside an LI element in the results list. Autocompleter will
+	 * provide 4 parameters: the results row, the position of the row in the list of
+	 * results (starting at 1), the number of items in the list of results and the search term.
+	 * The default behavior assumes that a single row contains a single value.
+	 */
+	public $formatItem;
+	/**
+	 * @var string a javascript function that can be used to limit the data that autocomplete
+	 * searches for matches. For example, there may be items you want displayed to the user,
+	 * but don't want included in the data that's searched. The function is called with the same arguments
+	 * as {@link formatItem}. Defaults to formatItem.
+	 */
+	public $formatMatch;
+	/**
+	 * @var string a javascript function that provides the formatting for the value to be
+	 * put into the input field. Again three arguments: Data, position (starting with one) and
+	 * total number of data. The default behavior assumes either plain data to use as result
+	 * or uses the same value as provided by formatItem.
+	 */
+	public $formatResult;
+	/**
+	 * @var boolean whether to allow more than one autocompleted-value to enter. Defaults to false.
+	 */
+	public $multiple;
+	/**
+	 * @var string seperator to put between values when using multiple option. Defaults to ", ".
+	 */
+	public $multipleSeparator;
+	/**
+	 * @var integer specify a custom width for the select box. Defaults to the width of the input element.
+	 */
+	public $width;
+	/**
+	 * @var boolean fill the textinput while still selecting a value, replacing the value
+	 * if more is typed or something else is selected. Defaults to false.
+	 */
+	public $autoFill;
+	/**
+	 * @var integer limit the number of items in the select box. Is also sent as
+	 * a "limit" parameter with a remote request. Defaults to 10.
+	 */
+	public $max;
+	/**
+	 * @var boolean|string Whether and how to highlight matches in the select box.
+	 * Set to false to disable. Set to a javascript function to customize.
+	 * The function gets the value as the first argument and the search term as the
+	 * second and must return the formatted value. Defaults to Wraps the search term in a &lt;strong&gt; element.
+	 */
+	public $highlight;
+	/**
+	 * @var boolean whether to scroll when more results than configured via scrollHeight are available. Defaults to true.
+	 */
+	public $scroll;
+	/**
+	 * @var integer height of scrolled autocomplete control in pixels. Defaults to 180.
+	 */
+	public $scrollHeight;
+	/**
+	 * @var string the CSS class for the input element. Defaults to "ac_input".
+	 */
+	public $inputClass;
+	/**
+	 * @var string the CSS class for the dropdown list. Defaults to "ac_results".
+	 */
+	public $resultsClass;
+	/**
+	 * @var string the CSS class used when the data is being loaded from backend. Defaults to "ac_loading".
+	 */
+	public $loadingClass;
+	/**
+	 * @var array additional options that can be passed to the constructor of the autocomplete js object.
+	 * This allows you to override existing functions of the autocomplete js class (e.g. the parse() function)
+	 */
+	public $options=array();
+	/**
+	 * @var string the chain of method calls that would be appended at the end of the autocomplete constructor.
+	 * For example, ".result(function(...){})" would cause the specified js function to execute
+	 * when the user selects an option.
+	 */
+	public $methodChain;
+
+	/**
+	 * Initializes the widget.
+	 * This method registers all needed client scripts and renders
+	 * the autocomplete input.
+	 */
+	public function init()
+	{
+		list($name,$id)=$this->resolveNameID();
+		$this->htmlOptions['id']=$id;
+		$this->htmlOptions['name']=$name;
+
+		$this->registerClientScript();
+
+
+		if($this->hasModel())
+		{
+			$field=$this->textArea ? 'activeTextArea' : 'activeTextField';
+			echo CHtml::$field($this->model,$this->attribute,$this->htmlOptions);
+		}
+		else
+		{
+			$field=$this->textArea ? 'textArea' : 'textField';
+			echo CHtml::$field($name,$this->value,$this->htmlOptions);
+		}
+	}
+
+	/**
+	 * Registers the needed CSS and JavaScript.
+	 * @since 1.0.1
+	 */
+	public function registerClientScript()
+	{
+		$id=$this->htmlOptions['id'];
+
+		$acOptions=$this->getClientOptions();
+		$options=$acOptions===array()?'{}' : CJavaScript::encode($acOptions);
+
+		$cs=Yii::app()->getClientScript();
+		$cs->registerCoreScript('autocomplete');
+		if($this->data!==null)
+			$data=CJavaScript::encode($this->data);
+		else
+		{
+			$url=CHtml::normalizeUrl($this->url);
+			$data='"'.$url.'"';
+		}
+		$cs->registerScript('Yii.CAutoComplete#'.$id,"jQuery(\"#{$id}\").autocomplete($data,{$options}){$this->methodChain};");
+
+		if($this->cssFile!==false)
+			self::registerCssFile($this->cssFile);
+	}
+
+	/**
+	 * Registers the needed CSS file.
+	 * @param string the CSS URL. If null, a default CSS URL will be used.
+	 * @since 1.0.2
+	 */
+	public static function registerCssFile($url=null)
+	{
+		return;
+		$cs=Yii::app()->getClientScript();
+		if($url===null)
+			$url=$cs->getCoreScriptUrl().'/autocomplete/jquery.autocomplete.css';
+		$cs->registerCssFile($url);
+	}
+
+	/**
+	 * @return array the javascript options
+	 */
+	protected function getClientOptions()
+	{
+		static $properties=array(
+			'minChars', 'delay', 'cacheLength', 'matchSubset',
+			'matchCase', 'matchContains', 'mustMatch', 'selectFirst',
+			'extraParams', 'multiple', 'multipleSeparator', 'width',
+			'autoFill', 'max', 'scroll', 'scrollHeight', 'inputClass',
+			'formatItem', 'formatMatch', 'formatResult', 'highlight',
+			'resultsClass', 'loadingClass');
+		static $functions=array('formatItem', 'formatMatch', 'formatResult', 'highlight');
+
+		$options=$this->options;
+		foreach($properties as $property)
+		{
+			if($this->$property!==null)
+				$options[$property]=$this->$property;
+		}
+		foreach($functions as $func)
+		{
+			if(is_string($this->$func) && strncmp($this->$func,'js:',3))
+				$options[$func]='js:'.$this->$func;
+		}
+
+		return $options;
+	}
+}