Cadoles
/
BeSimpleSoap
20
0
Fork 0
Code Issues 1 Pull Requests Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/complextype_pretty_name'

This commit is contained in:
Francis Besset 2013-08-05 09:54:08 +02:00
parent 232b678552 762ca4d7eb
commit bef19356d6
8 changed files with 149 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/BeSimple/SoapBundle/Resources/config/webservice.xml
View File

@ -15,7 +15,7 @@
<parameter key="besimple.soap.binder.response.documentwrapped.class">BeSimple\SoapBundle\ServiceBinding\DocumentLiteralWrappedResponseMessageBinder</parameter>
<parameter key="besimple.soap.definition.dumper.wsdl.rpcliteral.class">BeSimple\SoapBundle\ServiceDefinition\Dumper\WsdlDumper</parameter>
<parameter key="besimple.soap.type.repository.class">BeSimple\SoapBundle\Converter\TypeRepository</parameter>
<parameter key="besimple.soap.server.classmap.class">BeSimple\SoapCommon\Classmap</parameter>
<parameter key="besimple.soap.server.classmap.class">BeSimple\SoapServer\Classmap</parameter>
</parameters>
<services>

19
src/BeSimple/SoapBundle/Resources/doc/soapserver/tutorial/complex_type.rst
View File

@ -51,8 +51,16 @@ You can expose only the properties (public, protected or private) of a complex t
use BeSimple\SoapBundle\ServiceDefinition\Annotation as Soap;
/**
* @Soap\Alias("User")
*/
class User
{
/**
* @Soap\ComplexType("int", nillable=true)
*/
private $id;
/**
* @Soap\ComplexType("string")
*/
@ -63,11 +71,6 @@ You can expose only the properties (public, protected or private) of a complex t
*/
public $lastname;
/**
* @Soap\ComplexType("int", nillable=true)
*/
private $id;
/**
* @Soap\ComplexType("string")
*/
@ -135,3 +138,9 @@ ComplexType
`ComplexType` accepts the following options:
* nillable: To specify that the value can be null
Alias
-----
If you can Alias annotation, the name of your entity will be renamed in the WSDL generated.
With alias the name in WSDL will `User` instead of `Acme.DemoBundle.Entity.User` (name without Alias annotation).

36
src/BeSimple/SoapBundle/ServiceDefinition/Annotation/Alias.php Normal file
View File

@ -0,0 +1,36 @@
<?php
/*
* This file is part of the BeSimpleSoapBundle.
*
* (c) Christian Kerl <christian-kerl@web.de>
* (c) Francis Besset <francis.besset@gmail.com>
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
namespace BeSimple\SoapBundle\ServiceDefinition\Annotation;
/**
* @Annotation
*/
class Alias extends Configuration
{
private $value;
public function getValue()
{
return $this->value;
}
public function setValue($value)
{
$this->value = $value;
}
public function getAliasName()
{
return 'alias';
}
}

4
src/BeSimple/SoapBundle/ServiceDefinition/Annotation/Configuration.php
View File

@ -21,10 +21,10 @@ abstract class Configuration implements ConfigurationInterface
{
foreach ($values as $k => $v) {
if (!method_exists($this, $name = 'set'.$k)) {
throw new \RuntimeException(sprintf('Unknown key "%s" for annotation "@%s".', $k, get_class($this)));
throw new \RuntimeException(sprintf('Unknown key "%s" for annotation "@%s".', $k, __CLASS__));
}
$this->$name($v);
}
}
}
}

16
src/BeSimple/SoapBundle/ServiceDefinition/Loader/AnnotationComplexTypeLoader.php
View File

@ -22,6 +22,7 @@ use BeSimple\SoapBundle\Util\Collection;
*/
class AnnotationComplexTypeLoader extends AnnotationClassLoader
{
private $aliasClass = 'BeSimple\SoapBundle\ServiceDefinition\Annotation\Alias';
private $complexTypeClass = 'BeSimple\SoapBundle\ServiceDefinition\Annotation\ComplexType';
/**
@ -40,9 +41,14 @@ class AnnotationComplexTypeLoader extends AnnotationClassLoader
throw new \InvalidArgumentException(sprintf('Class "%s" does not exist.', $class));
}
$class = new \ReflectionClass($class);
$collection = new Collection('getName', 'BeSimple\SoapBundle\ServiceDefinition\ComplexType');
$annotations = array();
$class = new \ReflectionClass($class);
if ($alias = $this->reader->getClassAnnotation($class, $this->aliasClass)) {
$annotations['alias'] = $alias->getValue();
}
$annotations['properties'] = new Collection('getName', 'BeSimple\SoapBundle\ServiceDefinition\ComplexType');
foreach ($class->getProperties() as $property) {
$complexType = $this->reader->getPropertyAnnotation($property, $this->complexTypeClass);
@ -51,10 +57,10 @@ class AnnotationComplexTypeLoader extends AnnotationClassLoader
$propertyComplexType->setValue($complexType->getValue());
$propertyComplexType->setNillable($complexType->isNillable());
$propertyComplexType->setName($property->getName());
$collection->add($propertyComplexType);
$annotations['properties']->add($propertyComplexType);
}
}
return $collection;
return $annotations;
}
}
}

17
src/BeSimple/SoapBundle/ServiceDefinition/ServiceDefinition.php
View File

@ -128,13 +128,24 @@ class ServiceDefinition
$this->classmap = $classmap;
}
public function addDefinitionComplexType($type, Collection $complexType)
public function hasDefinitionComplexType($type)
{
$this->complexTypes[$type] = $complexType;
return isset($this->complexTypes[$type]);
}
public function addDefinitionComplexType($type, array $definition)
{
if ($this->hasDefinitionComplexType($type)) {
return false;
}
$this->complexTypes[$type] = $definition;
return true;
}
public function getDefinitionComplexTypes()
{
return $this->complexTypes;
}
}
}

47
src/BeSimple/SoapBundle/ServiceDefinition/Strategy/ComplexType.php
View File

@ -36,44 +36,45 @@ class ComplexType extends AbstractComplexTypeStrategy
* @param string $type Name of the class to be specified
* @return string XSD Type for the given PHP type
*/
public function addComplexType($type)
public function addComplexType($classname)
{
$classmap = $this->definition->getClassmap();
if (null !== $soapType = $this->scanRegisteredTypes($type)) {
return $soapType;
if ($classmap->hasByClassname($classname)) {
return 'tns:'.$classmap->getByClassname($classname);
}
if (!$this->loader->supports($type)) {
throw new \InvalidArgumentException(sprintf('Cannot add a complex type "%s" that is not an object or where class could not be found in "ComplexType" strategy.', $type));
if (!$this->loader->supports($classname)) {
throw new \InvalidArgumentException(sprintf('Cannot add ComplexType "%s" because it is not an object or the class could not be found.', $classname));
}
$dom = $this->getContext()->toDomDocument();
$definitionComplexType = $this->loader->load($classname);
$classnameAlias = isset($definitionComplexType['alias']) ? $definitionComplexType['alias'] : $classname;
$soapTypeName = $this->getContext()->translateType($type);
$soapType = 'tns:'.$soapTypeName;
if (!$classmap->has($soapTypeName)) {
$classmap->add($soapTypeName, $type);
}
$type = $this->getContext()->translateType($classnameAlias);
$xmlType = 'tns:'.$type;
// Register type here to avoid recursion
$this->getContext()->addType($type, $soapType);
$classmap->add($type, $classname);
$this->addXmlDefinition($definitionComplexType, $classname, $type);
return $xmlType;
}
private function addXmlDefinition(array $definitionComplexType, $classname, $type)
{
$dom = $this->getContext()->toDomDocument();
$complexType = $dom->createElement('xsd:complexType');
$complexType->setAttribute('name', $soapTypeName);
$complexType->setAttribute('name', $type);
$all = $dom->createElement('xsd:all');
$definitionComplexType = $this->loader->load($type);
$this->definition->addDefinitionComplexType($type, $definitionComplexType);
foreach ($definitionComplexType as $annotationComplexType) {
$elements = array();
foreach ($definitionComplexType['properties'] as $property) {
$element = $dom->createElement('xsd:element');
$element->setAttribute('name', $propertyName = $annotationComplexType->getName());
$element->setAttribute('type', $this->getContext()->getType(trim($annotationComplexType->getValue())));
$element->setAttribute('name', $property->getName());
$element->setAttribute('type', $this->getContext()->getType($property->getValue()));
if ($annotationComplexType->isNillable()) {
if ($property->isNillable()) {
$element->setAttribute('nillable', 'true');
}
@ -83,6 +84,6 @@ class ComplexType extends AbstractComplexTypeStrategy
$complexType->appendChild($all);
$this->getContext()->getSchema()->appendChild($complexType);
return $soapType;
$this->definition->addDefinitionComplexType($type, $definitionComplexType);
}
}

47
src/BeSimple/SoapServer/Classmap.php Normal file
View File

@ -0,0 +1,47 @@
<?php
/*
* This file is part of the BeSimpleSoapBundle.
*
* (c) Christian Kerl <christian-kerl@web.de>
* (c) Francis Besset <francis.besset@gmail.com>
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
namespace BeSimple\SoapServer;
use BeSimple\SoapCommon\Classmap as BaseClassmap;
/**
* @author Francis Besset <francis.besset@gmail.com>
*/
class Classmap extends BaseClassmap
{
protected $classmapInversed = array();
/**
* {@inheritdoc}
*/
public function add($type, $classname)
{
parent::add($type, $classname);
$this->classmapInversed[$classname] = $type;
}
public function getByClassname($classname)
{
if (!$this->hasByClassname($classname)) {
throw new \InvalidArgumentException(sprintf('The classname "%s" was not found in %s', $classname, __CLASS__));
}
return $this->classmapInversed[$classname];
}
public function hasByClassname($classname)
{
return isset($this->classmapInversed[$classname]);
}
}