WSCOMUN  2.1.0
Web Services Comunes para PHP/GVHidra
ComposerPortafirmas.php
1 <?php
2 namespace WSCOMUN\PORTAFIRMAS;
3 const unbounded = 'unbounded';
4 
12 {
20  protected function array2ObjectTree($array)
21  {
22  if (is_numeric(key($array)))
23  {
24  foreach ($array as $key => $value)
25  {
26  $array[$key] = $this->array_to_objecttree($value);
27  }
28  return $array;
29  }
30  $Object = new \stdClass;
31  foreach ($array as $key => $value)
32  {
33  if (is_array($value))
34  {
35  $Object->$key = $this->array_to_objecttree($value);
36  }
37  else
38  {
39  $Object->$key = $value;
40  }
41  }
42  return $Object;
43  }//Fin array2ObjectTree
44 
52  protected function objectTree2array($obj)
53  {
54  if (is_array($obj) || is_object($obj))
55  {
56  $result = array();
57  foreach ($obj as $key => $value)
58  {
59  $result[$key] = $this->objectTree2array($value);
60  }
61  return $result;
62  }
63  return $obj;
64  }//Fin objectTree2array
65 
66 
67  private function __anyType_SoapVar($childData, $fieldName, $namespace) {
68 //var_dump($childData);
69  if (is_a($childData, 'DateTime')) {
70 //var_dump($childData);
71 //die('DateTime: ' . $fieldName);
72  return new \SoapVar($childData->format(\DateTime::ATOM), XSD_DATETIME, 'dateTime', 'http://www.w3.org/2001/XMLSchema', $fieldName, $namespace);
73  } elseif (is_int($childData)) {
74 //die('Integer: ' . $fieldName);
75  return new \SoapVar($childData, XSD_INTEGER, null, null, $fieldName, $namespace);
76  }
77 
78 //die('Generic: ' . $fieldName);
79  return new \SoapVar($childData, XSD_STRING, 'string', 'http://www.w3.org/2001/XMLSchema', $fieldName, $namespace);
80  }
81 
82  private function __basic_SoapVar($childData, $basicType, $fieldName, $namespace) {
83  switch ($basicType) {
84  case XSD_DATETIME:
85  return new \SoapVar($childData->format(\DateTime::ATOM), $basicType, null, null, $fieldName, $namespace);
86 
87  default:
88  return new \SoapVar($childData, $basicType, null, null, $fieldName, $namespace);
89  }
90  }
91 
92  public function __doChild($parentTag, $value, $fieldName, $type, $namespace, $minOccurs, $maxOccurs)
93  {
94  //echo("__doChild: $type [$fieldName]<br>");
95  $fieldSet = isset($value);
96  if (!$fieldSet) {
97  if ($minOccurs > 0) {
98  throw new \Exception("No se ha encontrado el subcampo obligatorio '" . $fieldName . '"');
99  } else {
100  return true;
101  }
102  }
103 
104  $vChildData = $value;
105  if ($maxOccurs == 1) {
106  $vChildData = array( $value );
107  } else {
108  if ($maxOccurs != 'unbounded') {
109  if ($maxOccurs > sizeof($vChildData)) {
110  throw new \Exception("El campo '" . $fieldName . '" no tiene tantas ocurrencias como se esperaban');
111  }
112  } else {
113 // var_dump($vChildData);die;
114  }
115  }
116 
117 //var_dump(array_keys($vChildData));
118  for ($iIter=0; $iIter < sizeof($vChildData); $iIter++) {
119  $childData = $vChildData[$iIter];
120 
121  if ((($minOccurs > 0) && $fieldSet) || $fieldSet) {
122  if (is_int($type) && $type != SOAP_ENC_OBJECT) {
123 
124  $basicType = $type;
125 //echo("Basic: $type | $basicType [$fieldName]<br>");
126  if ($basicType !== XSD_ANYTYPE) {
127  $childSOAP = $this->__basic_SoapVar($childData, $basicType, $fieldName, $namespace);
128  } else {
129  $childSOAP = $this->__anyType_SoapVar($childData, $fieldName, $namespace);
130  }
131  $parentTag->append( $childSOAP );
132 // return true;
133 
134  } else { //if (isset($this->$funcName)) {
135  $childSOAP = $childData->toSoap($fieldName, $namespace);
136  $parentTag->append( $childSOAP );
137 // return true;
138  }
139  } else {
140  return false;
141  }
142 
143  }
144 
145  // TODO: HACER EL MULTIAPARICION!!!
146  /*
147  var_dump($parentTag);
148  var_dump($vData);
149  var_dump($fieldName);
150  var_dump($type);
151  var_dump($namespace);
152  var_dump($minOccurs);
153  var_dump($maxOccurs);
154 
155  die("FAIL!!!");
156  */
157 
158  return true;
159  }
160 
161 
162 
163  static public function is_assoc($array) {
164  foreach(array_keys($array) as $key) {
165  if (!is_int($key)) return true;
166  }
167  return false;
168  }
169 
170  static public function endsWith($haystack, $needle) {
171  // search forward starting from end minus needle length characters
172  return $needle === "" || (($temp = strlen($haystack) - strlen($needle)) >= 0 && strpos($haystack, $needle, $temp) !== false);
173  }
174 }
175 
176 
177 
178 class documentType extends SoapObject {
179  // name="identifier" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
180  private $_identifier = null;
181  private $_hasIdentifier = false;
182  public function setIdentifier($value) {
183  $this->_identifier = $value;
184  $this->_hasIdentifier = ($value !== null);
185  }
186  public function hasIdentifier() {
187  return $this->_hasIdentifier;
188  }
189  public function getIdentifier() {
190  return $this->_identifier;
191  }
192 
193  // name="description" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
194  private $_description = null;
195  private $_hasDescription = false;
196  public function setDescription($value) {
197  $this->_description = $value;
198  $this->_hasDescription = ($value !== null);
199  }
200  public function hasDescription() {
201  return $this->_hasDescription;
202  }
203  public function getDescription() {
204  return $this->_description;
205  }
206 
207  // name="valid" type="xsd:boolean"[102] minOccurs="0" maxOccurs="1" nillable="true"
208  private $_valid = null;
209  private $_hasValid = false;
210  public function setValid($value) {
211  $this->_valid = $value;
212  $this->_hasValid = ($value !== null);
213  }
214  public function hasValid() {
215  return $this->_hasValid;
216  }
217  public function getValid() {
218  return $this->_valid;
219  }
220 
221 
222  static public function fromSoap($vData) {
223  $newItem = new documentType();
224  if (isset($vData['identifier'])) {
225  $newItem->setIdentifier($vData['identifier']);
226  }
227  if (isset($vData['description'])) {
228  $newItem->setDescription($vData['description']);
229  }
230  if (isset($vData['valid'])) {
231  $newItem->setValid($vData['valid']);
232  }
233 
234  return $newItem;
235  }
236  public function toSoap($fieldName, $namespace) {
237  $myLevel = new \ArrayObject();
238 
239  $this->__doChild($myLevel, $this->_identifier, 'identifier', 101, $namespace, 0, 1);
240  $this->__doChild($myLevel, $this->_description, 'description', 101, $namespace, 0, 1);
241  $this->__doChild($myLevel, $this->_valid, 'valid', 102, $namespace, 0, 1);
242 
243  //return $myLevel;
244  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
245  }
246 }
247 
249  // name="documentType" type="type:documentType"[COMPLEXTYPE] minOccurs="0" maxOccurs="unbounded" nillable="false"
250  private $_documentType = array();
251  private $_hasDocumentType = false;
252  public function replaceArrayDocumentType($value) {
253  $this->_documentType = $value;
254  $this->_hasDocumentType = (isset($this->_documentType) && !empty($this->_documentType));
255  }
256  public function retrieveArrayDocumentType() {
257  return $this->_documentType;
258  }
259  public function addDocumentType($value) {
260  array_push($this->_documentType, $value);
261  $this->_hasDocumentType = (isset($this->_documentType) && !empty($this->_documentType));
262  }
263  public function hasDocumentType() {
264  return $this->_hasDocumentType;
265  }
266  public function getDocumentType($index) {
267  return $this->_documentType[$index];
268  }
269  public function countDocumentType() {
270  return count($this->_documentType);
271  }
272 
273 
274  static public function fromSoap($vData) {
275  $newItem = new documentTypeList();
276  if (isset($vData['documentType']) && !empty($vData['documentType'])) {
277  if (SoapObject::is_assoc($vData['documentType'])) {
278  // Si es asociativo, lo probable es que nos encontremos ante un array de un solo elemento de forma que directamente se ha introducido el elemento a tratar
279  $newClass = documentType::fromSoap($vData['documentType']);
280  $newItem->addDocumentType($newClass);
281  } else {
282  foreach ($vData['documentType'] as $oVar) {
283  $newClass = documentType::fromSoap($oVar);
284  $newItem->addDocumentType($newClass);
285  }
286  }
287  }
288 
289  return $newItem;
290  }
291  public function toSoap($fieldName, $namespace) {
292  $myLevel = new \ArrayObject();
293 
294  $this->__doChild($myLevel, $this->_documentType, 'documentType', SOAP_ENC_OBJECT, $namespace, 0, unbounded);
295 
296  //return $myLevel;
297  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
298  }
299 }
300 
302  // name="levelCode" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
303  private $_levelCode = null;
304  private $_hasLevelCode = false;
305  public function setLevelCode($value) {
306  $this->_levelCode = $value;
307  $this->_hasLevelCode = ($value !== null);
308  }
309  public function hasLevelCode() {
310  return $this->_hasLevelCode;
311  }
312  public function getLevelCode() {
313  return $this->_levelCode;
314  }
315 
316  // name="description" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
317  private $_description = null;
318  private $_hasDescription = false;
319  public function setDescription($value) {
320  $this->_description = $value;
321  $this->_hasDescription = ($value !== null);
322  }
323  public function hasDescription() {
324  return $this->_hasDescription;
325  }
326  public function getDescription() {
327  return $this->_description;
328  }
329 
330 
331  static public function fromSoap($vData) {
332  $newItem = new importanceLevel();
333  if (isset($vData['levelCode'])) {
334  $newItem->setLevelCode($vData['levelCode']);
335  }
336  if (isset($vData['description'])) {
337  $newItem->setDescription($vData['description']);
338  }
339 
340  return $newItem;
341  }
342  public function toSoap($fieldName, $namespace) {
343  $myLevel = new \ArrayObject();
344 
345  $this->__doChild($myLevel, $this->_levelCode, 'levelCode', 101, $namespace, 0, 1);
346  $this->__doChild($myLevel, $this->_description, 'description', 101, $namespace, 0, 1);
347 
348  //return $myLevel;
349  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
350  }
351 }
352 
354  // name="importanceLevels" type="type:importanceLevel"[COMPLEXTYPE] minOccurs="0" maxOccurs="unbounded" nillable="false"
355  private $_importanceLevels = array();
356  private $_hasImportanceLevels = false;
357  public function replaceArrayImportanceLevels($value) {
358  $this->_importanceLevels = $value;
359  $this->_hasImportanceLevels = (isset($this->_importanceLevels) && !empty($this->_importanceLevels));
360  }
361  public function retrieveArrayImportanceLevels() {
362  return $this->_importanceLevels;
363  }
364  public function addImportanceLevels($value) {
365  array_push($this->_importanceLevels, $value);
366  $this->_hasImportanceLevels = (isset($this->_importanceLevels) && !empty($this->_importanceLevels));
367  }
368  public function hasImportanceLevels() {
369  return $this->_hasImportanceLevels;
370  }
371  public function getImportanceLevels($index) {
372  return $this->_importanceLevels[$index];
373  }
374  public function countImportanceLevels() {
375  return count($this->_importanceLevels);
376  }
377 
378 
379  static public function fromSoap($vData) {
380  $newItem = new importanceLevelList();
381  if (isset($vData['importanceLevels']) && !empty($vData['importanceLevels'])) {
382  if (SoapObject::is_assoc($vData['importanceLevels'])) {
383  // Si es asociativo, lo probable es que nos encontremos ante un array de un solo elemento de forma que directamente se ha introducido el elemento a tratar
384  $newClass = importanceLevel::fromSoap($vData['importanceLevels']);
385  $newItem->addImportanceLevels($newClass);
386  } else {
387  foreach ($vData['importanceLevels'] as $oVar) {
388  $newClass = importanceLevel::fromSoap($oVar);
389  $newItem->addImportanceLevels($newClass);
390  }
391  }
392  }
393 
394  return $newItem;
395  }
396  public function toSoap($fieldName, $namespace) {
397  $myLevel = new \ArrayObject();
398 
399  $this->__doChild($myLevel, $this->_importanceLevels, 'importanceLevels', SOAP_ENC_OBJECT, $namespace, 0, unbounded);
400 
401  //return $myLevel;
402  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
403  }
404 }
405 
406 class state extends SoapObject {
407  // name="identifier" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
408  private $_identifier = null;
409  private $_hasIdentifier = false;
410  public function setIdentifier($value) {
411  $this->_identifier = $value;
412  $this->_hasIdentifier = ($value !== null);
413  }
414  public function hasIdentifier() {
415  return $this->_hasIdentifier;
416  }
417  public function getIdentifier() {
418  return $this->_identifier;
419  }
420 
421 
422  static public function fromSoap($vData) {
423  $newItem = new state();
424  if (isset($vData['identifier'])) {
425  $newItem->setIdentifier($vData['identifier']);
426  }
427 
428  return $newItem;
429  }
430  public function toSoap($fieldName, $namespace) {
431  $myLevel = new \ArrayObject();
432 
433  $this->__doChild($myLevel, $this->_identifier, 'identifier', 101, $namespace, 0, 1);
434 
435  //return $myLevel;
436  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
437  }
438 }
439 
440 class stateList extends SoapObject {
441  // name="state" type="type:state"[COMPLEXTYPE] minOccurs="0" maxOccurs="unbounded" nillable="false"
442  private $_state = array();
443  private $_hasState = false;
444  public function replaceArrayState($value) {
445  $this->_state = $value;
446  $this->_hasState = (isset($this->_state) && !empty($this->_state));
447  }
448  public function retrieveArrayState() {
449  return $this->_state;
450  }
451  public function addState($value) {
452  array_push($this->_state, $value);
453  $this->_hasState = (isset($this->_state) && !empty($this->_state));
454  }
455  public function hasState() {
456  return $this->_hasState;
457  }
458  public function getState($index) {
459  return $this->_state[$index];
460  }
461  public function countState() {
462  return count($this->_state);
463  }
464 
465 
466  static public function fromSoap($vData) {
467  $newItem = new stateList();
468  if (isset($vData['state']) && !empty($vData['state'])) {
469  if (SoapObject::is_assoc($vData['state'])) {
470  // Si es asociativo, lo probable es que nos encontremos ante un array de un solo elemento de forma que directamente se ha introducido el elemento a tratar
471  $newClass = state::fromSoap($vData['state']);
472  $newItem->addState($newClass);
473  } else {
474  foreach ($vData['state'] as $oVar) {
475  $newClass = state::fromSoap($oVar);
476  $newItem->addState($newClass);
477  }
478  }
479  }
480 
481  return $newItem;
482  }
483  public function toSoap($fieldName, $namespace) {
484  $myLevel = new \ArrayObject();
485 
486  $this->__doChild($myLevel, $this->_state, 'state', SOAP_ENC_OBJECT, $namespace, 0, unbounded);
487 
488  //return $myLevel;
489  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
490  }
491 }
492 
493 class userJob extends SoapObject {
494  // name="identifier" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
495  private $_identifier = null;
496  private $_hasIdentifier = false;
497  public function setIdentifier($value) {
498  $this->_identifier = $value;
499  $this->_hasIdentifier = ($value !== null);
500  }
501  public function hasIdentifier() {
502  return $this->_hasIdentifier;
503  }
504  public function getIdentifier() {
505  return $this->_identifier;
506  }
507 
508  function __construct() {
509  throw new \Exception('La clase userJob no debe utilizarse directamente. Debe instanciarse en su lugar "user" o "job"');
510  }
511 
512  static public function fromSoap($vData) {
513  $isUser = null;
514  if (isset($vData['@attributes']) && isset($vData['@attributes']['type'])) {
515  if (SoapObject::endsWith($vData['@attributes']['type'], ':user')) {
516  $isUser = true;
517  } elseif (SoapObject::endsWith($vData['@attributes']['type'], ':job')) {
518  $isUser = false;
519  }
520  } elseif (isset($vData['name'])) {
521  $isUser = true;
522  } elseif (isset($vData['description'])) {
523  $isUser = false;
524  }
525 
526  if (is_null($isUser)) {
527  throw new \Exception('No se ha podido determinar la subclase de userJob. No se ha encontrado "@attributes", "name" ni "description" para poder clasificarlo');
528  }
529 
530  if ($isUser) {
531  return user::fromSoap($vData);
532  } else {
533  return job::fromSoap($vData);
534  }
535 
536  return null;
537  }
538  public function toSoap($fieldName, $namespace) {
539  $myLevel = new \ArrayObject();
540 
541  $this->__doChild($myLevel, $this->_identifier, 'identifier', 101, $namespace, 0, 1);
542 
543  //return $myLevel;
544  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
545  }
546 }
547 
548 class user extends SoapObject {
549  // name="identifier" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
550  private $_identifier = null;
551  private $_hasIdentifier = false;
552  public function setIdentifier($value) {
553  $this->_identifier = $value;
554  $this->_hasIdentifier = ($value !== null);
555  }
556  public function hasIdentifier() {
557  return $this->_hasIdentifier;
558  }
559  public function getIdentifier() {
560  return $this->_identifier;
561  }
562 
563  // name="name" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
564  private $_name = null;
565  private $_hasName = false;
566  public function setName($value) {
567  $this->_name = $value;
568  $this->_hasName = ($value !== null);
569  }
570  public function hasName() {
571  return $this->_hasName;
572  }
573  public function getName() {
574  return $this->_name;
575  }
576 
577  // name="surname1" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
578  private $_surname1 = null;
579  private $_hasSurname1 = false;
580  public function setSurname1($value) {
581  $this->_surname1 = $value;
582  $this->_hasSurname1 = ($value !== null);
583  }
584  public function hasSurname1() {
585  return $this->_hasSurname1;
586  }
587  public function getSurname1() {
588  return $this->_surname1;
589  }
590 
591  // name="surname2" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
592  private $_surname2 = null;
593  private $_hasSurname2 = false;
594  public function setSurname2($value) {
595  $this->_surname2 = $value;
596  $this->_hasSurname2 = ($value !== null);
597  }
598  public function hasSurname2() {
599  return $this->_hasSurname2;
600  }
601  public function getSurname2() {
602  return $this->_surname2;
603  }
604 
605 
606  static public function fromSoap($vData) {
607  $newItem = new user();
608  if (isset($vData['identifier'])) {
609  $newItem->setIdentifier($vData['identifier']);
610  }
611  if (isset($vData['name'])) {
612  $newItem->setName($vData['name']);
613  }
614  if (isset($vData['surname1'])) {
615  $newItem->setSurname1($vData['surname1']);
616  }
617  if (isset($vData['surname2'])) {
618  $newItem->setSurname2($vData['surname2']);
619  }
620 
621  return $newItem;
622  }
623  public function toSoap($fieldName, $namespace) {
624  $vData = array();
625  $vData['identifier'] = $this->_identifier;
626  $vData['name'] = $this->_name;
627  $vData['surname1'] = $this->_surname1;
628  $vData['surname2'] = $this->_surname2;
629 
630  return new \SoapVar($vData, SOAP_ENC_OBJECT, 'user', 'urn:juntadeandalucia:cice:pfirma:type:v2.0', $fieldName, $namespace);
631 
632  /*
633  $myLevel = new \ArrayObject();
634 
635  $this->__doChild($myLevel, $this->_identifier, 'identifier', 101, $namespace, 0, 1);
636  $this->__doChild($myLevel, $this->_name, 'name', 101, $namespace, 0, 1);
637  $this->__doChild($myLevel, $this->_surname1, 'surname1', 101, $namespace, 0, 1);
638  $this->__doChild($myLevel, $this->_surname2, 'surname2', 101, $namespace, 0, 1);
639 
640  //return $myLevel;
641  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
642  */
643  }
644 }
645 
646 class job extends SoapObject {
647  // name="identifier" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
648  private $_identifier = null;
649  private $_hasIdentifier = false;
650  public function setIdentifier($value) {
651  $this->_identifier = $value;
652  $this->_hasIdentifier = ($value !== null);
653  }
654  public function hasIdentifier() {
655  return $this->_hasIdentifier;
656  }
657  public function getIdentifier() {
658  return $this->_identifier;
659  }
660 
661  // name="description" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
662  private $_description = null;
663  private $_hasDescription = false;
664  public function setDescription($value) {
665  $this->_description = $value;
666  $this->_hasDescription = ($value !== null);
667  }
668  public function hasDescription() {
669  return $this->_hasDescription;
670  }
671  public function getDescription() {
672  return $this->_description;
673  }
674 
675 
676  static public function fromSoap($vData) {
677  $newItem = new job();
678  if (isset($vData['identifier'])) {
679  $newItem->setIdentifier($vData['identifier']);
680  }
681  if (isset($vData['description'])) {
682  $newItem->setDescription($vData['description']);
683  }
684 
685  return $newItem;
686  }
687  public function toSoap($fieldName, $namespace) {
688  $vData = array();
689  $vData['identifier'] = $this->_identifier;
690  $vData['description'] = $this->_description;
691 
692  return new \SoapVar($vData, SOAP_ENC_OBJECT, 'job', 'urn:juntadeandalucia:cice:pfirma:type:v2.0', $fieldName, $namespace);
693 
694  /*
695  $myLevel = new \ArrayObject();
696 
697  $this->__doChild($myLevel, $this->_identifier, 'identifier', 101, $namespace, 0, 1);
698  $this->__doChild($myLevel, $this->_description, 'description', 101, $namespace, 0, 1);
699 
700  //return $myLevel;
701  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
702  */
703  }
704 }
705 
706 class jobList extends SoapObject {
707  // name="job" type="type:job"[COMPLEXTYPE] minOccurs="0" maxOccurs="unbounded" nillable="false"
708  private $_job = array();
709  private $_hasJob = false;
710  public function replaceArrayJob($value) {
711  $this->_job = $value;
712  $this->_hasJob = (isset($this->_job) && !empty($this->_job));
713  }
714  public function retrieveArrayJob() {
715  return $this->_job;
716  }
717  public function addJob($value) {
718  array_push($this->_job, $value);
719  $this->_hasJob = (isset($this->_job) && !empty($this->_job));
720  }
721  public function hasJob() {
722  return $this->_hasJob;
723  }
724  public function getJob($index) {
725  return $this->_job[$index];
726  }
727  public function countJob() {
728  return count($this->_job);
729  }
730 
731 
732  static public function fromSoap($vData) {
733  $newItem = new jobList();
734  if (isset($vData['job']) && !empty($vData['job'])) {
735  if (SoapObject::is_assoc($vData['job'])) {
736  // Si es asociativo, lo probable es que nos encontremos ante un array de un solo elemento de forma que directamente se ha introducido el elemento a tratar
737  $newClass = job::fromSoap($vData['job']);
738  $newItem->addJob($newClass);
739  } else {
740  foreach ($vData['job'] as $oVar) {
741  $newClass = job::fromSoap($oVar);
742  $newItem->addJob($newClass);
743  }
744  }
745  }
746 
747  return $newItem;
748  }
749  public function toSoap($fieldName, $namespace) {
750  $myLevel = new \ArrayObject();
751 
752  $this->__doChild($myLevel, $this->_job, 'job', SOAP_ENC_OBJECT, $namespace, 0, unbounded);
753 
754  //return $myLevel;
755  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
756  }
757 }
758 
759 class userList extends SoapObject {
760  // name="user" type="type:user"[COMPLEXTYPE] minOccurs="0" maxOccurs="unbounded" nillable="false"
761  private $_user = array();
762  private $_hasUser = false;
763  public function replaceArrayUser($value) {
764  $this->_user = $value;
765  $this->_hasUser = (isset($this->_user) && !empty($this->_user));
766  }
767  public function retrieveArrayUser() {
768  return $this->_user;
769  }
770  public function addUser($value) {
771  array_push($this->_user, $value);
772  $this->_hasUser = (isset($this->_user) && !empty($this->_user));
773  }
774  public function hasUser() {
775  return $this->_hasUser;
776  }
777  public function getUser($index) {
778  return $this->_user[$index];
779  }
780  public function countUser() {
781  return count($this->_user);
782  }
783 
784 
785  static public function fromSoap($vData) {
786  $newItem = new userList();
787  if (isset($vData['user']) && !empty($vData['user'])) {
788  if (SoapObject::is_assoc($vData['user'])) {
789  // Si es asociativo, lo probable es que nos encontremos ante un array de un solo elemento de forma que directamente se ha introducido el elemento a tratar
790  $newClass = user::fromSoap($vData['user']);
791  $newItem->addUser($newClass);
792  } else {
793  foreach ($vData['user'] as $oVar) {
794  $newClass = user::fromSoap($oVar);
795  $newItem->addUser($newClass);
796  }
797  }
798  }
799 
800  return $newItem;
801  }
802  public function toSoap($fieldName, $namespace) {
803  $myLevel = new \ArrayObject();
804 
805  $this->__doChild($myLevel, $this->_user, 'user', SOAP_ENC_OBJECT, $namespace, 0, unbounded);
806 
807  //return $myLevel;
808  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
809  }
810 }
811 
812 class seat extends SoapObject {
813  // name="code" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
814  private $_code = null;
815  private $_hasCode = false;
816  public function setCode($value) {
817  $this->_code = $value;
818  $this->_hasCode = ($value !== null);
819  }
820  public function hasCode() {
821  return $this->_hasCode;
822  }
823  public function getCode() {
824  return $this->_code;
825  }
826 
827  // name="description" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
828  private $_description = null;
829  private $_hasDescription = false;
830  public function setDescription($value) {
831  $this->_description = $value;
832  $this->_hasDescription = ($value !== null);
833  }
834  public function hasDescription() {
835  return $this->_hasDescription;
836  }
837  public function getDescription() {
838  return $this->_description;
839  }
840 
841 
842  static public function fromSoap($vData) {
843  $newItem = new seat();
844  if (isset($vData['code'])) {
845  $newItem->setCode($vData['code']);
846  }
847  if (isset($vData['description'])) {
848  $newItem->setDescription($vData['description']);
849  }
850 
851  return $newItem;
852  }
853  public function toSoap($fieldName, $namespace) {
854  $myLevel = new \ArrayObject();
855 
856  $this->__doChild($myLevel, $this->_code, 'code', 101, $namespace, 0, 1);
857  $this->__doChild($myLevel, $this->_description, 'description', 101, $namespace, 0, 1);
858 
859  //return $myLevel;
860  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
861  }
862 }
863 
864 class seatList extends SoapObject {
865  // name="seat" type="type:seat"[COMPLEXTYPE] minOccurs="0" maxOccurs="unbounded" nillable="false"
866  private $_seat = array();
867  private $_hasSeat = false;
868  public function replaceArraySeat($value) {
869  $this->_seat = $value;
870  $this->_hasSeat = (isset($this->_seat) && !empty($this->_seat));
871  }
872  public function retrieveArraySeat() {
873  return $this->_seat;
874  }
875  public function addSeat($value) {
876  array_push($this->_seat, $value);
877  $this->_hasSeat = (isset($this->_seat) && !empty($this->_seat));
878  }
879  public function hasSeat() {
880  return $this->_hasSeat;
881  }
882  public function getSeat($index) {
883  return $this->_seat[$index];
884  }
885  public function countSeat() {
886  return count($this->_seat);
887  }
888 
889 
890  static public function fromSoap($vData) {
891  $newItem = new seatList();
892  if (isset($vData['seat']) && !empty($vData['seat'])) {
893  if (SoapObject::is_assoc($vData['seat'])) {
894  // Si es asociativo, lo probable es que nos encontremos ante un array de un solo elemento de forma que directamente se ha introducido el elemento a tratar
895  $newClass = seat::fromSoap($vData['seat']);
896  $newItem->addSeat($newClass);
897  } else {
898  foreach ($vData['seat'] as $oVar) {
899  $newClass = seat::fromSoap($oVar);
900  $newItem->addSeat($newClass);
901  }
902  }
903  }
904 
905  return $newItem;
906  }
907  public function toSoap($fieldName, $namespace) {
908  $myLevel = new \ArrayObject();
909 
910  $this->__doChild($myLevel, $this->_seat, 'seat', SOAP_ENC_OBJECT, $namespace, 0, unbounded);
911 
912  //return $myLevel;
913  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
914  }
915 }
916 
918  // name="seat" type="type:seat"[COMPLEXTYPE] minOccurs="0" maxOccurs="1" nillable="true"
919  private $_seat = null;
920  private $_hasSeat = false;
921  public function setSeat($value) {
922  $this->_seat = $value;
923  $this->_hasSeat = ($value !== null);
924  }
925  public function hasSeat() {
926  return $this->_hasSeat;
927  }
928  public function getSeat() {
929  return $this->_seat;
930  }
931 
932  // name="valid" type="xsd:boolean"[102] minOccurs="0" maxOccurs="1" nillable="true"
933  private $_valid = null;
934  private $_hasValid = false;
935  public function setValid($value) {
936  $this->_valid = $value;
937  $this->_hasValid = ($value !== null);
938  }
939  public function hasValid() {
940  return $this->_hasValid;
941  }
942  public function getValid() {
943  return $this->_valid;
944  }
945 
946  // name="visibleOtherSeats" type="xsd:boolean"[102] minOccurs="0" maxOccurs="1" nillable="true"
947  private $_visibleOtherSeats = null;
948  private $_hasVisibleOtherSeats = false;
949  public function setVisibleOtherSeats($value) {
950  $this->_visibleOtherSeats = $value;
951  $this->_hasVisibleOtherSeats = ($value !== null);
952  }
953  public function hasVisibleOtherSeats() {
954  return $this->_hasVisibleOtherSeats;
955  }
956  public function getVisibleOtherSeats() {
957  return $this->_visibleOtherSeats;
958  }
959 
960  // name="parameterList" type="type:parameterList"[COMPLEXTYPE] minOccurs="0" maxOccurs="1" nillable="true"
961  private $_parameterList = null;
962  private $_hasParameterList = false;
963  public function setParameterList($value) {
964  $this->_parameterList = $value;
965  $this->_hasParameterList = ($value !== null);
966  }
967  public function hasParameterList() {
968  return $this->_hasParameterList;
969  }
970  public function getParameterList() {
971  return $this->_parameterList;
972  }
973 
974 
975  static public function fromSoap($vData) {
976  $newItem = new enhancedUserJobInfo();
977  if (isset($vData['seat'])) {
978  $newClass = seat::fromSoap($vData['seat']);
979  $newItem->setSeat($newClass);
980  }
981  if (isset($vData['valid'])) {
982  $newItem->setValid($vData['valid']);
983  }
984  if (isset($vData['visibleOtherSeats'])) {
985  $newItem->setVisibleOtherSeats($vData['visibleOtherSeats']);
986  }
987  if (isset($vData['parameterList'])) {
988  $newClass = parameterList::fromSoap($vData['parameterList']);
989  $newItem->setParameterList($newClass);
990  }
991 
992  return $newItem;
993  }
994  public function toSoap($fieldName, $namespace) {
995  $myLevel = new \ArrayObject();
996 
997  $this->__doChild($myLevel, $this->_seat, 'seat', SOAP_ENC_OBJECT, $namespace, 0, 1);
998  $this->__doChild($myLevel, $this->_valid, 'valid', 102, $namespace, 0, 1);
999  $this->__doChild($myLevel, $this->_visibleOtherSeats, 'visibleOtherSeats', 102, $namespace, 0, 1);
1000  $this->__doChild($myLevel, $this->_parameterList, 'parameterList', SOAP_ENC_OBJECT, $namespace, 0, 1);
1001 
1002  //return $myLevel;
1003  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
1004  }
1005 }
1006 
1007 class enhancedUser extends SoapObject {
1008  // name="user" type="type:user"[COMPLEXTYPE] minOccurs="0" maxOccurs="1" nillable="true"
1009  private $_user = null;
1010  private $_hasUser = false;
1011  public function setUser($value) {
1012  $this->_user = $value;
1013  $this->_hasUser = ($value !== null);
1014  }
1015  public function hasUser() {
1016  return $this->_hasUser;
1017  }
1018  public function getUser() {
1019  return $this->_user;
1020  }
1021 
1022  // name="enhancedUserJobInfo" type="type:enhancedUserJobInfo"[COMPLEXTYPE] minOccurs="0" maxOccurs="1" nillable="true"
1023  private $_enhancedUserJobInfo = null;
1024  private $_hasEnhancedUserJobInfo = false;
1025  public function setEnhancedUserJobInfo($value) {
1026  $this->_enhancedUserJobInfo = $value;
1027  $this->_hasEnhancedUserJobInfo = ($value !== null);
1028  }
1029  public function hasEnhancedUserJobInfo() {
1030  return $this->_hasEnhancedUserJobInfo;
1031  }
1032  public function getEnhancedUserJobInfo() {
1033  return $this->_enhancedUserJobInfo;
1034  }
1035 
1036 
1037  static public function fromSoap($vData) {
1038  $newItem = new enhancedUser();
1039  if (isset($vData['user'])) {
1040  $newClass = user::fromSoap($vData['user']);
1041  $newItem->setUser($newClass);
1042  }
1043  if (isset($vData['enhancedUserJobInfo'])) {
1044  $newClass = enhancedUserJobInfo::fromSoap($vData['enhancedUserJobInfo']);
1045  $newItem->setEnhancedUserJobInfo($newClass);
1046  }
1047 
1048  return $newItem;
1049  }
1050  public function toSoap($fieldName, $namespace) {
1051  $myLevel = new \ArrayObject();
1052 
1053  $this->__doChild($myLevel, $this->_user, 'user', SOAP_ENC_OBJECT, $namespace, 0, 1);
1054  $this->__doChild($myLevel, $this->_enhancedUserJobInfo, 'enhancedUserJobInfo', SOAP_ENC_OBJECT, $namespace, 0, 1);
1055 
1056  //return $myLevel;
1057  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
1058  }
1059 }
1060 
1061 class enhancedJob extends SoapObject {
1062  // name="job" type="type:job"[COMPLEXTYPE] minOccurs="0" maxOccurs="1" nillable="true"
1063  private $_job = null;
1064  private $_hasJob = false;
1065  public function setJob($value) {
1066  $this->_job = $value;
1067  $this->_hasJob = ($value !== null);
1068  }
1069  public function hasJob() {
1070  return $this->_hasJob;
1071  }
1072  public function getJob() {
1073  return $this->_job;
1074  }
1075 
1076  // name="enhancedUserJobInfo" type="type:enhancedUserJobInfo"[COMPLEXTYPE] minOccurs="0" maxOccurs="1" nillable="true"
1077  private $_enhancedUserJobInfo = null;
1078  private $_hasEnhancedUserJobInfo = false;
1079  public function setEnhancedUserJobInfo($value) {
1080  $this->_enhancedUserJobInfo = $value;
1081  $this->_hasEnhancedUserJobInfo = ($value !== null);
1082  }
1083  public function hasEnhancedUserJobInfo() {
1084  return $this->_hasEnhancedUserJobInfo;
1085  }
1086  public function getEnhancedUserJobInfo() {
1087  return $this->_enhancedUserJobInfo;
1088  }
1089 
1090 
1091  static public function fromSoap($vData) {
1092  $newItem = new enhancedJob();
1093  if (isset($vData['job'])) {
1094  $newClass = job::fromSoap($vData['job']);
1095  $newItem->setJob($newClass);
1096  }
1097  if (isset($vData['enhancedUserJobInfo'])) {
1098  $newClass = enhancedUserJobInfo::fromSoap($vData['enhancedUserJobInfo']);
1099  $newItem->setEnhancedUserJobInfo($newClass);
1100  }
1101 
1102  return $newItem;
1103  }
1104  public function toSoap($fieldName, $namespace) {
1105  $myLevel = new \ArrayObject();
1106 
1107  $this->__doChild($myLevel, $this->_job, 'job', SOAP_ENC_OBJECT, $namespace, 0, 1);
1108  $this->__doChild($myLevel, $this->_enhancedUserJobInfo, 'enhancedUserJobInfo', SOAP_ENC_OBJECT, $namespace, 0, 1);
1109 
1110  //return $myLevel;
1111  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
1112  }
1113 }
1114 
1116  // name="enhancedUser" type="type:enhancedUser"[COMPLEXTYPE] minOccurs="0" maxOccurs="unbounded" nillable="false"
1117  private $_enhancedUser = array();
1118  private $_hasEnhancedUser = false;
1119  public function replaceArrayEnhancedUser($value) {
1120  $this->_enhancedUser = $value;
1121  $this->_hasEnhancedUser = (isset($this->_enhancedUser) && !empty($this->_enhancedUser));
1122  }
1123  public function retrieveArrayEnhancedUser() {
1124  return $this->_enhancedUser;
1125  }
1126  public function addEnhancedUser($value) {
1127  array_push($this->_enhancedUser, $value);
1128  $this->_hasEnhancedUser = (isset($this->_enhancedUser) && !empty($this->_enhancedUser));
1129  }
1130  public function hasEnhancedUser() {
1131  return $this->_hasEnhancedUser;
1132  }
1133  public function getEnhancedUser($index) {
1134  return $this->_enhancedUser[$index];
1135  }
1136  public function countEnhancedUser() {
1137  return count($this->_enhancedUser);
1138  }
1139 
1140 
1141  static public function fromSoap($vData) {
1142  $newItem = new enhancedUserList();
1143  if (isset($vData['enhancedUser']) && !empty($vData['enhancedUser'])) {
1144  if (SoapObject::is_assoc($vData['enhancedUser'])) {
1145  // Si es asociativo, lo probable es que nos encontremos ante un array de un solo elemento de forma que directamente se ha introducido el elemento a tratar
1146  $newClass = enhancedUser::fromSoap($vData['enhancedUser']);
1147  $newItem->addEnhancedUser($newClass);
1148  } else {
1149  foreach ($vData['enhancedUser'] as $oVar) {
1150  $newClass = enhancedUser::fromSoap($oVar);
1151  $newItem->addEnhancedUser($newClass);
1152  }
1153  }
1154  }
1155 
1156  return $newItem;
1157  }
1158  public function toSoap($fieldName, $namespace) {
1159  $myLevel = new \ArrayObject();
1160 
1161  $this->__doChild($myLevel, $this->_enhancedUser, 'enhancedUser', SOAP_ENC_OBJECT, $namespace, 0, unbounded);
1162 
1163  //return $myLevel;
1164  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
1165  }
1166 }
1167 
1169  // name="enhancedJob" type="type:enhancedJob"[COMPLEXTYPE] minOccurs="0" maxOccurs="unbounded" nillable="false"
1170  private $_enhancedJob = array();
1171  private $_hasEnhancedJob = false;
1172  public function replaceArrayEnhancedJob($value) {
1173  $this->_enhancedJob = $value;
1174  $this->_hasEnhancedJob = (isset($this->_enhancedJob) && !empty($this->_enhancedJob));
1175  }
1176  public function retrieveArrayEnhancedJob() {
1177  return $this->_enhancedJob;
1178  }
1179  public function addEnhancedJob($value) {
1180  array_push($this->_enhancedJob, $value);
1181  $this->_hasEnhancedJob = (isset($this->_enhancedJob) && !empty($this->_enhancedJob));
1182  }
1183  public function hasEnhancedJob() {
1184  return $this->_hasEnhancedJob;
1185  }
1186  public function getEnhancedJob($index) {
1187  return $this->_enhancedJob[$index];
1188  }
1189  public function countEnhancedJob() {
1190  return count($this->_enhancedJob);
1191  }
1192 
1193 
1194  static public function fromSoap($vData) {
1195  $newItem = new enhancedJobList();
1196  if (isset($vData['enhancedJob']) && !empty($vData['enhancedJob'])) {
1197  if (SoapObject::is_assoc($vData['enhancedJob'])) {
1198  // Si es asociativo, lo probable es que nos encontremos ante un array de un solo elemento de forma que directamente se ha introducido el elemento a tratar
1199  $newClass = enhancedJob::fromSoap($vData['enhancedJob']);
1200  $newItem->addEnhancedJob($newClass);
1201  } else {
1202  foreach ($vData['enhancedJob'] as $oVar) {
1203  $newClass = enhancedJob::fromSoap($oVar);
1204  $newItem->addEnhancedJob($newClass);
1205  }
1206  }
1207  }
1208 
1209  return $newItem;
1210  }
1211  public function toSoap($fieldName, $namespace) {
1212  $myLevel = new \ArrayObject();
1213 
1214  $this->__doChild($myLevel, $this->_enhancedJob, 'enhancedJob', SOAP_ENC_OBJECT, $namespace, 0, unbounded);
1215 
1216  //return $myLevel;
1217  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
1218  }
1219 }
1220 
1222  // name="enhancedUser" type="type:enhancedUser"[COMPLEXTYPE] minOccurs="1" maxOccurs="1" nillable="false"
1223  private $_enhancedUser = null;
1224  private $_hasEnhancedUser = false;
1225  public function setEnhancedUser($value) {
1226  $this->_enhancedUser = $value;
1227  $this->_hasEnhancedUser = ($value !== null);
1228  }
1229  public function hasEnhancedUser() {
1230  return $this->_hasEnhancedUser;
1231  }
1232  public function getEnhancedUser() {
1233  return $this->_enhancedUser;
1234  }
1235 
1236  // name="enhancedJob" type="type:enhancedJob"[COMPLEXTYPE] minOccurs="1" maxOccurs="1" nillable="false"
1237  private $_enhancedJob = null;
1238  private $_hasEnhancedJob = false;
1239  public function setEnhancedJob($value) {
1240  $this->_enhancedJob = $value;
1241  $this->_hasEnhancedJob = ($value !== null);
1242  }
1243  public function hasEnhancedJob() {
1244  return $this->_hasEnhancedJob;
1245  }
1246  public function getEnhancedJob() {
1247  return $this->_enhancedJob;
1248  }
1249 
1250  // name="fstart" type="xsd:dateTime"[107] minOccurs="1" maxOccurs="1" nillable="false"
1251  private $_fstart = null;
1252  private $_hasFstart = false;
1253  public function setFstart($value) {
1254  $this->_fstart = $value;
1255  $this->_hasFstart = ($value !== null);
1256  }
1257  public function hasFstart() {
1258  return $this->_hasFstart;
1259  }
1260  public function getFstart() {
1261  return $this->_fstart;
1262  }
1263 
1264  // name="fend" type="xsd:dateTime"[107] minOccurs="0" maxOccurs="1" nillable="true"
1265  private $_fend = null;
1266  private $_hasFend = false;
1267  public function setFend($value) {
1268  $this->_fend = $value;
1269  $this->_hasFend = ($value !== null);
1270  }
1271  public function hasFend() {
1272  return $this->_hasFend;
1273  }
1274  public function getFend() {
1275  return $this->_fend;
1276  }
1277 
1278 
1279  static public function fromSoap($vData) {
1280  $newItem = new enhancedUserJobAssociated();
1281  if (!isset($vData['enhancedUser'])) {
1282  throw new \Exception('El parametro enhancedUser es obligatorio');
1283  }
1284  if (isset($vData['enhancedUser'])) {
1285  $newClass = enhancedUser::fromSoap($vData['enhancedUser']);
1286  $newItem->setEnhancedUser($newClass);
1287  }
1288  if (!isset($vData['enhancedJob'])) {
1289  throw new \Exception('El parametro enhancedJob es obligatorio');
1290  }
1291  if (isset($vData['enhancedJob'])) {
1292  $newClass = enhancedJob::fromSoap($vData['enhancedJob']);
1293  $newItem->setEnhancedJob($newClass);
1294  }
1295  if (!isset($vData['fstart'])) {
1296  throw new \Exception('El parametro fstart es obligatorio');
1297  }
1298  if (isset($vData['fstart'])) {
1299  $newItem->setFstart($vData['fstart']);
1300  }
1301  if (isset($vData['fend'])) {
1302  $newItem->setFend($vData['fend']);
1303  }
1304 
1305  return $newItem;
1306  }
1307  public function toSoap($fieldName, $namespace) {
1308  $myLevel = new \ArrayObject();
1309 
1310  $this->__doChild($myLevel, $this->_enhancedUser, 'enhancedUser', SOAP_ENC_OBJECT, $namespace, 1, 1);
1311  $this->__doChild($myLevel, $this->_enhancedJob, 'enhancedJob', SOAP_ENC_OBJECT, $namespace, 1, 1);
1312  $this->__doChild($myLevel, $this->_fstart, 'fstart', 107, $namespace, 1, 1);
1313  $this->__doChild($myLevel, $this->_fend, 'fend', 107, $namespace, 0, 1);
1314 
1315  //return $myLevel;
1316  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
1317  }
1318 }
1319 
1321  // name="enhancedUserJobAssociated" type="type:enhancedUserJobAssociated"[COMPLEXTYPE] minOccurs="0" maxOccurs="unbounded" nillable="false"
1322  private $_enhancedUserJobAssociated = array();
1323  private $_hasEnhancedUserJobAssociated = false;
1324  public function replaceArrayEnhancedUserJobAssociated($value) {
1325  $this->_enhancedUserJobAssociated = $value;
1326  $this->_hasEnhancedUserJobAssociated = (isset($this->_enhancedUserJobAssociated) && !empty($this->_enhancedUserJobAssociated));
1327  }
1328  public function retrieveArrayEnhancedUserJobAssociated() {
1329  return $this->_enhancedUserJobAssociated;
1330  }
1331  public function addEnhancedUserJobAssociated($value) {
1332  array_push($this->_enhancedUserJobAssociated, $value);
1333  $this->_hasEnhancedUserJobAssociated = (isset($this->_enhancedUserJobAssociated) && !empty($this->_enhancedUserJobAssociated));
1334  }
1335  public function hasEnhancedUserJobAssociated() {
1336  return $this->_hasEnhancedUserJobAssociated;
1337  }
1338  public function getEnhancedUserJobAssociated($index) {
1339  return $this->_enhancedUserJobAssociated[$index];
1340  }
1341  public function countEnhancedUserJobAssociated() {
1342  return count($this->_enhancedUserJobAssociated);
1343  }
1344 
1345 
1346  static public function fromSoap($vData) {
1347  $newItem = new enhancedUserJobAssociatedList();
1348  if (isset($vData['enhancedUserJobAssociated']) && !empty($vData['enhancedUserJobAssociated'])) {
1349  if (SoapObject::is_assoc($vData['enhancedUserJobAssociated'])) {
1350  // Si es asociativo, lo probable es que nos encontremos ante un array de un solo elemento de forma que directamente se ha introducido el elemento a tratar
1351  $newClass = enhancedUserJobAssociated::fromSoap($vData['enhancedUserJobAssociated']);
1352  $newItem->addEnhancedUserJobAssociated($newClass);
1353  } else {
1354  foreach ($vData['enhancedUserJobAssociated'] as $oVar) {
1355  $newClass = enhancedUserJobAssociated::fromSoap($oVar);
1356  $newItem->addEnhancedUserJobAssociated($newClass);
1357  }
1358  }
1359  }
1360 
1361  return $newItem;
1362  }
1363  public function toSoap($fieldName, $namespace) {
1364  $myLevel = new \ArrayObject();
1365 
1366  $this->__doChild($myLevel, $this->_enhancedUserJobAssociated, 'enhancedUserJobAssociated', SOAP_ENC_OBJECT, $namespace, 0, unbounded);
1367 
1368  //return $myLevel;
1369  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
1370  }
1371 }
1372 
1373 class parameter extends SoapObject {
1374  // name="identifier" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
1375  private $_identifier = null;
1376  private $_hasIdentifier = false;
1377  public function setIdentifier($value) {
1378  $this->_identifier = $value;
1379  $this->_hasIdentifier = ($value !== null);
1380  }
1381  public function hasIdentifier() {
1382  return $this->_hasIdentifier;
1383  }
1384  public function getIdentifier() {
1385  return $this->_identifier;
1386  }
1387 
1388  // name="value" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
1389  private $_value = null;
1390  private $_hasValue = false;
1391  public function setValue($value) {
1392  $this->_value = $value;
1393  $this->_hasValue = ($value !== null);
1394  }
1395  public function hasValue() {
1396  return $this->_hasValue;
1397  }
1398  public function getValue() {
1399  return $this->_value;
1400  }
1401 
1402 
1403  static public function fromSoap($vData) {
1404  $newItem = new parameter();
1405  if (isset($vData['identifier'])) {
1406  $newItem->setIdentifier($vData['identifier']);
1407  }
1408  if (isset($vData['value'])) {
1409  $newItem->setValue($vData['value']);
1410  }
1411 
1412  return $newItem;
1413  }
1414  public function toSoap($fieldName, $namespace) {
1415  $myLevel = new \ArrayObject();
1416 
1417  $this->__doChild($myLevel, $this->_identifier, 'identifier', 101, $namespace, 0, 1);
1418  $this->__doChild($myLevel, $this->_value, 'value', 101, $namespace, 0, 1);
1419 
1420  //return $myLevel;
1421  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
1422  }
1423 }
1424 
1425 class request extends SoapObject {
1426  // name="identifier" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
1427  private $_identifier = null;
1428  private $_hasIdentifier = false;
1429  public function setIdentifier($value) {
1430  $this->_identifier = $value;
1431  $this->_hasIdentifier = ($value !== null);
1432  }
1433  public function hasIdentifier() {
1434  return $this->_hasIdentifier;
1435  }
1436  public function getIdentifier() {
1437  return $this->_identifier;
1438  }
1439 
1440  // name="subject" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
1441  private $_subject = null;
1442  private $_hasSubject = false;
1443  public function setSubject($value) {
1444  $this->_subject = $value;
1445  $this->_hasSubject = ($value !== null);
1446  }
1447  public function hasSubject() {
1448  return $this->_hasSubject;
1449  }
1450  public function getSubject() {
1451  return $this->_subject;
1452  }
1453 
1454  // name="fentry" type="xsd:dateTime"[107] minOccurs="0" maxOccurs="1" nillable="false"
1455  private $_fentry = null;
1456  private $_hasFentry = false;
1457  public function setFentry($value) {
1458  $this->_fentry = $value;
1459  $this->_hasFentry = ($value !== null);
1460  }
1461  public function hasFentry() {
1462  return $this->_hasFentry;
1463  }
1464  public function getFentry() {
1465  return $this->_fentry;
1466  }
1467 
1468  // name="fstart" type="xsd:dateTime"[107] minOccurs="0" maxOccurs="1" nillable="false"
1469  private $_fstart = null;
1470  private $_hasFstart = false;
1471  public function setFstart($value) {
1472  $this->_fstart = $value;
1473  $this->_hasFstart = ($value !== null);
1474  }
1475  public function hasFstart() {
1476  return $this->_hasFstart;
1477  }
1478  public function getFstart() {
1479  return $this->_fstart;
1480  }
1481 
1482  // name="fexpiration" type="xsd:dateTime"[107] minOccurs="0" maxOccurs="1" nillable="false"
1483  private $_fexpiration = null;
1484  private $_hasFexpiration = false;
1485  public function setFexpiration($value) {
1486  $this->_fexpiration = $value;
1487  $this->_hasFexpiration = ($value !== null);
1488  }
1489  public function hasFexpiration() {
1490  return $this->_hasFexpiration;
1491  }
1492  public function getFexpiration() {
1493  return $this->_fexpiration;
1494  }
1495 
1496  // name="reference" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
1497  private $_reference = null;
1498  private $_hasReference = false;
1499  public function setReference($value) {
1500  $this->_reference = $value;
1501  $this->_hasReference = ($value !== null);
1502  }
1503  public function hasReference() {
1504  return $this->_hasReference;
1505  }
1506  public function getReference() {
1507  return $this->_reference;
1508  }
1509 
1510  // name="text" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
1511  private $_text = null;
1512  private $_hasText = false;
1513  public function setText($value) {
1514  $this->_text = $value;
1515  $this->_hasText = ($value !== null);
1516  }
1517  public function hasText() {
1518  return $this->_hasText;
1519  }
1520  public function getText() {
1521  return $this->_text;
1522  }
1523 
1524  // name="signType" type="type:signType"[101] minOccurs="0" maxOccurs="1" nillable="true"
1525  private $_signType = null;
1526  private $_hasSignType = false;
1527  public function setSignType($value) {
1528  $this->_signType = $value;
1529  $this->_hasSignType = ($value !== null);
1530  }
1531  public function hasSignType() {
1532  return $this->_hasSignType;
1533  }
1534  public function getSignType() {
1535  return $this->_signType;
1536  }
1537 
1538  // name="application" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
1539  private $_application = null;
1540  private $_hasApplication = false;
1541  public function setApplication($value) {
1542  $this->_application = $value;
1543  $this->_hasApplication = ($value !== null);
1544  }
1545  public function hasApplication() {
1546  return $this->_hasApplication;
1547  }
1548  public function getApplication() {
1549  return $this->_application;
1550  }
1551 
1552  // name="importanceLevel" type="type:importanceLevel"[COMPLEXTYPE] minOccurs="0" maxOccurs="1" nillable="true"
1553  private $_importanceLevel = null;
1554  private $_hasImportanceLevel = false;
1555  public function setImportanceLevel($value) {
1556  $this->_importanceLevel = $value;
1557  $this->_hasImportanceLevel = ($value !== null);
1558  }
1559  public function hasImportanceLevel() {
1560  return $this->_hasImportanceLevel;
1561  }
1562  public function getImportanceLevel() {
1563  return $this->_importanceLevel;
1564  }
1565 
1566  // name="documentList" type="type:documentList"[COMPLEXTYPE] minOccurs="0" maxOccurs="1" nillable="true"
1567  private $_documentList = null;
1568  private $_hasDocumentList = false;
1569  public function setDocumentList($value) {
1570  $this->_documentList = $value;
1571  $this->_hasDocumentList = ($value !== null);
1572  }
1573  public function hasDocumentList() {
1574  return $this->_hasDocumentList;
1575  }
1576  public function getDocumentList() {
1577  return $this->_documentList;
1578  }
1579 
1580  // name="signLineList" type="type:signLineList"[COMPLEXTYPE] minOccurs="0" maxOccurs="1" nillable="true"
1581  private $_signLineList = null;
1582  private $_hasSignLineList = false;
1583  public function setSignLineList($value) {
1584  $this->_signLineList = $value;
1585  $this->_hasSignLineList = ($value !== null);
1586  }
1587  public function hasSignLineList() {
1588  return $this->_hasSignLineList;
1589  }
1590  public function getSignLineList() {
1591  return $this->_signLineList;
1592  }
1593 
1594  // name="remitterList" type="type:remitterList"[COMPLEXTYPE] minOccurs="0" maxOccurs="1" nillable="true"
1595  private $_remitterList = null;
1596  private $_hasRemitterList = false;
1597  public function setRemitterList($value) {
1598  $this->_remitterList = $value;
1599  $this->_hasRemitterList = ($value !== null);
1600  }
1601  public function hasRemitterList() {
1602  return $this->_hasRemitterList;
1603  }
1604  public function getRemitterList() {
1605  return $this->_remitterList;
1606  }
1607 
1608  // name="parameterList" type="type:parameterList"[COMPLEXTYPE] minOccurs="0" maxOccurs="1" nillable="true"
1609  private $_parameterList = null;
1610  private $_hasParameterList = false;
1611  public function setParameterList($value) {
1612  $this->_parameterList = $value;
1613  $this->_hasParameterList = ($value !== null);
1614  }
1615  public function hasParameterList() {
1616  return $this->_hasParameterList;
1617  }
1618  public function getParameterList() {
1619  return $this->_parameterList;
1620  }
1621 
1622  // name="noticeList" type="type:noticeList"[COMPLEXTYPE] minOccurs="0" maxOccurs="1" nillable="true"
1623  private $_noticeList = null;
1624  private $_hasNoticeList = false;
1625  public function setNoticeList($value) {
1626  $this->_noticeList = $value;
1627  $this->_hasNoticeList = ($value !== null);
1628  }
1629  public function hasNoticeList() {
1630  return $this->_hasNoticeList;
1631  }
1632  public function getNoticeList() {
1633  return $this->_noticeList;
1634  }
1635 
1636  // name="actionList" type="type:actionList"[COMPLEXTYPE] minOccurs="0" maxOccurs="1" nillable="true"
1637  private $_actionList = null;
1638  private $_hasActionList = false;
1639  public function setActionList($value) {
1640  $this->_actionList = $value;
1641  $this->_hasActionList = ($value !== null);
1642  }
1643  public function hasActionList() {
1644  return $this->_hasActionList;
1645  }
1646  public function getActionList() {
1647  return $this->_actionList;
1648  }
1649 
1650  // name="commentList" type="type:commentList"[COMPLEXTYPE] minOccurs="0" maxOccurs="1" nillable="true"
1651  private $_commentList = null;
1652  private $_hasCommentList = false;
1653  public function setCommentList($value) {
1654  $this->_commentList = $value;
1655  $this->_hasCommentList = ($value !== null);
1656  }
1657  public function hasCommentList() {
1658  return $this->_hasCommentList;
1659  }
1660  public function getCommentList() {
1661  return $this->_commentList;
1662  }
1663 
1664  // name="requestStatus" type="type:requestStatus"[101] minOccurs="0" maxOccurs="1" nillable="true"
1665  private $_requestStatus = null;
1666  private $_hasRequestStatus = false;
1667  public function setRequestStatus($value) {
1668  $this->_requestStatus = $value;
1669  $this->_hasRequestStatus = ($value !== null);
1670  }
1671  public function hasRequestStatus() {
1672  return $this->_hasRequestStatus;
1673  }
1674  public function getRequestStatus() {
1675  return $this->_requestStatus;
1676  }
1677 
1678  // name="timestampInfo" type="type:timestampInfo"[COMPLEXTYPE] minOccurs="0" maxOccurs="1" nillable="true"
1679  private $_timestampInfo = null;
1680  private $_hasTimestampInfo = false;
1681  public function setTimestampInfo($value) {
1682  $this->_timestampInfo = $value;
1683  $this->_hasTimestampInfo = ($value !== null);
1684  }
1685  public function hasTimestampInfo() {
1686  return $this->_hasTimestampInfo;
1687  }
1688  public function getTimestampInfo() {
1689  return $this->_timestampInfo;
1690  }
1691 
1692 
1693  static public function fromSoap($vData) {
1694  $newItem = new request();
1695  if (isset($vData['identifier'])) {
1696  $newItem->setIdentifier($vData['identifier']);
1697  }
1698  if (isset($vData['subject'])) {
1699  $newItem->setSubject($vData['subject']);
1700  }
1701  if (isset($vData['fentry'])) {
1702  $newItem->setFentry($vData['fentry']);
1703  }
1704  if (isset($vData['fstart'])) {
1705  $newItem->setFstart($vData['fstart']);
1706  }
1707  if (isset($vData['fexpiration'])) {
1708  $newItem->setFexpiration($vData['fexpiration']);
1709  }
1710  if (isset($vData['reference'])) {
1711  $newItem->setReference($vData['reference']);
1712  }
1713  if (isset($vData['text'])) {
1714  $newItem->setText($vData['text']);
1715  }
1716  if (isset($vData['signType'])) {
1717  $newItem->setSignType($vData['signType']);
1718  }
1719  if (isset($vData['application'])) {
1720  $newItem->setApplication($vData['application']);
1721  }
1722  if (isset($vData['importanceLevel'])) {
1723  $newClass = importanceLevel::fromSoap($vData['importanceLevel']);
1724  $newItem->setImportanceLevel($newClass);
1725  }
1726  if (isset($vData['documentList'])) {
1727  $newClass = documentList::fromSoap($vData['documentList']);
1728  $newItem->setDocumentList($newClass);
1729  }
1730  if (isset($vData['signLineList'])) {
1731  $newClass = signLineList::fromSoap($vData['signLineList']);
1732  $newItem->setSignLineList($newClass);
1733  }
1734  if (isset($vData['remitterList'])) {
1735  $newClass = remitterList::fromSoap($vData['remitterList']);
1736  $newItem->setRemitterList($newClass);
1737  }
1738  if (isset($vData['parameterList'])) {
1739  $newClass = parameterList::fromSoap($vData['parameterList']);
1740  $newItem->setParameterList($newClass);
1741  }
1742  if (isset($vData['noticeList'])) {
1743  $newClass = noticeList::fromSoap($vData['noticeList']);
1744  $newItem->setNoticeList($newClass);
1745  }
1746  if (isset($vData['actionList'])) {
1747  $newClass = CPFactionList::fromSoap($vData['actionList']);
1748  $newItem->setActionList($newClass);
1749  }
1750  if (isset($vData['commentList'])) {
1751  $newClass = commentList::fromSoap($vData['commentList']);
1752  $newItem->setCommentList($newClass);
1753  }
1754  if (isset($vData['requestStatus'])) {
1755  $newItem->setRequestStatus($vData['requestStatus']);
1756  }
1757  if (isset($vData['timestampInfo'])) {
1758  $newClass = timestampInfo::fromSoap($vData['timestampInfo']);
1759  $newItem->setTimestampInfo($newClass);
1760  }
1761 
1762  return $newItem;
1763  }
1764  public function toSoap($fieldName, $namespace) {
1765  $myLevel = new \ArrayObject();
1766 
1767  $this->__doChild($myLevel, $this->_identifier, 'identifier', 101, $namespace, 0, 1);
1768  $this->__doChild($myLevel, $this->_subject, 'subject', 101, $namespace, 0, 1);
1769  $this->__doChild($myLevel, $this->_fentry, 'fentry', 107, $namespace, 0, 1);
1770  $this->__doChild($myLevel, $this->_fstart, 'fstart', 107, $namespace, 0, 1);
1771  $this->__doChild($myLevel, $this->_fexpiration, 'fexpiration', 107, $namespace, 0, 1);
1772  $this->__doChild($myLevel, $this->_reference, 'reference', 101, $namespace, 0, 1);
1773  $this->__doChild($myLevel, $this->_text, 'text', 101, $namespace, 0, 1);
1774  $this->__doChild($myLevel, $this->_signType, 'signType', 101, $namespace, 0, 1);
1775  $this->__doChild($myLevel, $this->_application, 'application', 101, $namespace, 0, 1);
1776  $this->__doChild($myLevel, $this->_importanceLevel, 'importanceLevel', SOAP_ENC_OBJECT, $namespace, 0, 1);
1777  $this->__doChild($myLevel, $this->_documentList, 'documentList', SOAP_ENC_OBJECT, $namespace, 0, 1);
1778  $this->__doChild($myLevel, $this->_signLineList, 'signLineList', SOAP_ENC_OBJECT, $namespace, 0, 1);
1779  $this->__doChild($myLevel, $this->_remitterList, 'remitterList', SOAP_ENC_OBJECT, $namespace, 0, 1);
1780  $this->__doChild($myLevel, $this->_parameterList, 'parameterList', SOAP_ENC_OBJECT, $namespace, 0, 1);
1781  $this->__doChild($myLevel, $this->_noticeList, 'noticeList', SOAP_ENC_OBJECT, $namespace, 0, 1);
1782  $this->__doChild($myLevel, $this->_actionList, 'actionList', SOAP_ENC_OBJECT, $namespace, 0, 1);
1783  $this->__doChild($myLevel, $this->_commentList, 'commentList', SOAP_ENC_OBJECT, $namespace, 0, 1);
1784  $this->__doChild($myLevel, $this->_requestStatus, 'requestStatus', 101, $namespace, 0, 1);
1785  $this->__doChild($myLevel, $this->_timestampInfo, 'timestampInfo', SOAP_ENC_OBJECT, $namespace, 0, 1);
1786 
1787  //return $myLevel;
1788  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
1789  }
1790 }
1791 
1792 class document extends SoapObject {
1793  // name="identifier" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
1794  private $_identifier = null;
1795  private $_hasIdentifier = false;
1796  public function setIdentifier($value) {
1797  $this->_identifier = $value;
1798  $this->_hasIdentifier = ($value !== null);
1799  }
1800  public function hasIdentifier() {
1801  return $this->_hasIdentifier;
1802  }
1803  public function getIdentifier() {
1804  return $this->_identifier;
1805  }
1806 
1807  // name="name" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
1808  private $_name = null;
1809  private $_hasName = false;
1810  public function setName($value) {
1811  $this->_name = $value;
1812  $this->_hasName = ($value !== null);
1813  }
1814  public function hasName() {
1815  return $this->_hasName;
1816  }
1817  public function getName() {
1818  return $this->_name;
1819  }
1820 
1821  // name="mime" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
1822  private $_mime = null;
1823  private $_hasMime = false;
1824  public function setMime($value) {
1825  $this->_mime = $value;
1826  $this->_hasMime = ($value !== null);
1827  }
1828  public function hasMime() {
1829  return $this->_hasMime;
1830  }
1831  public function getMime() {
1832  return $this->_mime;
1833  }
1834 
1835  // name="documentType" type="type:documentType"[COMPLEXTYPE] minOccurs="0" maxOccurs="1" nillable="true"
1836  private $_documentType = null;
1837  private $_hasDocumentType = false;
1838  public function setDocumentType($value) {
1839  $this->_documentType = $value;
1840  $this->_hasDocumentType = ($value !== null);
1841  }
1842  public function hasDocumentType() {
1843  return $this->_hasDocumentType;
1844  }
1845  public function getDocumentType() {
1846  return $this->_documentType;
1847  }
1848 
1849  // name="content" type="xsd:base64Binary"[116] minOccurs="0" maxOccurs="1" nillable="true"
1850  private $_content = null;
1851  private $_hasContent = false;
1852  public function setContent($value) {
1853  $this->_content = $value;
1854  $this->_hasContent = ($value !== null);
1855  }
1856  public function hasContent() {
1857  return $this->_hasContent;
1858  }
1859  public function getContent() {
1860  return $this->_content;
1861  }
1862 
1863  // name="type" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
1864  private $_type = null;
1865  private $_hasType = false;
1866  public function setType($value) {
1867  $this->_type = $value;
1868  $this->_hasType = ($value !== null);
1869  }
1870  public function hasType() {
1871  return $this->_hasType;
1872  }
1873  public function getType() {
1874  return $this->_type;
1875  }
1876 
1877  // name="uri" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
1878  private $_uri = null;
1879  private $_hasUri = false;
1880  public function setUri($value) {
1881  $this->_uri = $value;
1882  $this->_hasUri = ($value !== null);
1883  }
1884  public function hasUri() {
1885  return $this->_hasUri;
1886  }
1887  public function getUri() {
1888  return $this->_uri;
1889  }
1890 
1891  // name="sign" type="xsd:boolean"[102] minOccurs="0" maxOccurs="1" nillable="true"
1892  private $_sign = null;
1893  private $_hasSign = false;
1894  public function setSign($value) {
1895  $this->_sign = $value;
1896  $this->_hasSign = ($value !== null);
1897  }
1898  public function hasSign() {
1899  return $this->_hasSign;
1900  }
1901  public function getSign() {
1902  return $this->_sign;
1903  }
1904 
1905  // name="generarCSV" type="xsd:boolean"[102] minOccurs="0" maxOccurs="1" nillable="true"
1906  private $_generarCSV = null;
1907  private $_hasGenerarCSV = false;
1908  public function setGenerarCSV($value) {
1909  $this->_generarCSV = $value;
1910  $this->_hasGenerarCSV = ($value !== null);
1911  }
1912  public function hasGenerarCSV() {
1913  return $this->_hasGenerarCSV;
1914  }
1915  public function getGenerarCSV() {
1916  return $this->_generarCSV;
1917  }
1918 
1919  // name="firmaposicion" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
1920  private $_firmaposicion = null;
1921  private $_hasFirmaposicion = false;
1922  public function setFirmaposicion($value) {
1923  $this->_firmaposicion = $value;
1924  $this->_hasFirmaposicion = ($value !== null);
1925  }
1926  public function hasFirmaposicion() {
1927  return $this->_hasFirmaposicion;
1928  }
1929  public function getFirmaposicion() {
1930  return $this->_firmaposicion;
1931  }
1932 
1933 
1934  static public function fromSoap($vData) {
1935  $newItem = new document();
1936  if (isset($vData['identifier'])) {
1937  $newItem->setIdentifier($vData['identifier']);
1938  }
1939  if (isset($vData['name'])) {
1940  $newItem->setName($vData['name']);
1941  }
1942  if (isset($vData['mime'])) {
1943  $newItem->setMime($vData['mime']);
1944  }
1945  if (isset($vData['documentType'])) {
1946  $newClass = documentType::fromSoap($vData['documentType']);
1947  $newItem->setDocumentType($newClass);
1948  }
1949  if (isset($vData['content'])) {
1950  $newItem->setContent($vData['content']);
1951  }
1952  if (isset($vData['type'])) {
1953  $newItem->setType($vData['type']);
1954  }
1955  if (isset($vData['uri'])) {
1956  $newItem->setUri($vData['uri']);
1957  }
1958  if (isset($vData['sign'])) {
1959  $newItem->setSign($vData['sign']);
1960  }
1961  if (isset($vData['generarCSV'])) {
1962  $newItem->setGenerarCSV($vData['generarCSV']);
1963  }
1964  if (isset($vData['firmaposicion'])) {
1965  $newItem->setFirmaposicion($vData['firmaposicion']);
1966  }
1967 
1968  return $newItem;
1969  }
1970  public function toSoap($fieldName, $namespace) {
1971  $myLevel = new \ArrayObject();
1972 
1973  $this->__doChild($myLevel, $this->_identifier, 'identifier', 101, $namespace, 0, 1);
1974  $this->__doChild($myLevel, $this->_name, 'name', 101, $namespace, 0, 1);
1975  $this->__doChild($myLevel, $this->_mime, 'mime', 101, $namespace, 0, 1);
1976  $this->__doChild($myLevel, $this->_documentType, 'documentType', SOAP_ENC_OBJECT, $namespace, 0, 1);
1977  $this->__doChild($myLevel, $this->_content, 'content', 116, $namespace, 0, 1);
1978  $this->__doChild($myLevel, $this->_type, 'type', 101, $namespace, 0, 1);
1979  $this->__doChild($myLevel, $this->_uri, 'uri', 101, $namespace, 0, 1);
1980  $this->__doChild($myLevel, $this->_sign, 'sign', 102, $namespace, 0, 1);
1981  $this->__doChild($myLevel, $this->_generarCSV, 'generarCSV', 102, $namespace, 0, 1);
1982  $this->__doChild($myLevel, $this->_firmaposicion, 'firmaposicion', 101, $namespace, 0, 1);
1983 
1984  //return $myLevel;
1985  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
1986  }
1987 }
1988 
1989 class documentList extends SoapObject {
1990  // name="document" type="type:document"[COMPLEXTYPE] minOccurs="0" maxOccurs="unbounded" nillable="false"
1991  private $_document = array();
1992  private $_hasDocument = false;
1993  public function replaceArrayDocument($value) {
1994  $this->_document = $value;
1995  $this->_hasDocument = (isset($this->_document) && !empty($this->_document));
1996  }
1997  public function retrieveArrayDocument() {
1998  return $this->_document;
1999  }
2000  public function addDocument($value) {
2001  array_push($this->_document, $value);
2002  $this->_hasDocument = (isset($this->_document) && !empty($this->_document));
2003  }
2004  public function hasDocument() {
2005  return $this->_hasDocument;
2006  }
2007  public function getDocument($index) {
2008  return $this->_document[$index];
2009  }
2010  public function countDocument() {
2011  return count($this->_document);
2012  }
2013 
2014 
2015  static public function fromSoap($vData) {
2016  $newItem = new documentList();
2017  if (isset($vData['document']) && !empty($vData['document'])) {
2018  if (SoapObject::is_assoc($vData['document'])) {
2019  // Si es asociativo, lo probable es que nos encontremos ante un array de un solo elemento de forma que directamente se ha introducido el elemento a tratar
2020  $newClass = document::fromSoap($vData['document']);
2021  $newItem->addDocument($newClass);
2022  } else {
2023  foreach ($vData['document'] as $oVar) {
2024  $newClass = document::fromSoap($oVar);
2025  $newItem->addDocument($newClass);
2026  }
2027  }
2028  }
2029 
2030  return $newItem;
2031  }
2032  public function toSoap($fieldName, $namespace) {
2033  $myLevel = new \ArrayObject();
2034 
2035  $this->__doChild($myLevel, $this->_document, 'document', SOAP_ENC_OBJECT, $namespace, 0, unbounded);
2036 
2037  //return $myLevel;
2038  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
2039  }
2040 }
2041 
2042 class signLine extends SoapObject {
2043  // name="signerList" type="type:signerList"[COMPLEXTYPE] minOccurs="0" maxOccurs="1" nillable="true"
2044  private $_signerList = null;
2045  private $_hasSignerList = false;
2046  public function setSignerList($value) {
2047  $this->_signerList = $value;
2048  $this->_hasSignerList = ($value !== null);
2049  }
2050  public function hasSignerList() {
2051  return $this->_hasSignerList;
2052  }
2053  public function getSignerList() {
2054  return $this->_signerList;
2055  }
2056 
2057  // name="type" type="type:signLineType"[101] minOccurs="0" maxOccurs="1" nillable="true"
2058  private $_type = null;
2059  private $_hasType = false;
2060  public function setType($value) {
2061  $this->_type = $value;
2062  $this->_hasType = ($value !== null);
2063  }
2064  public function hasType() {
2065  return $this->_hasType;
2066  }
2067  public function getType() {
2068  return $this->_type;
2069  }
2070 
2071 
2072  static public function fromSoap($vData) {
2073  $newItem = new signLine();
2074  if (isset($vData['signerList'])) {
2075  $newClass = signerList::fromSoap($vData['signerList']);
2076  $newItem->setSignerList($newClass);
2077  }
2078  if (isset($vData['type'])) {
2079  $newItem->setType($vData['type']);
2080  }
2081 
2082  return $newItem;
2083  }
2084  public function toSoap($fieldName, $namespace) {
2085  $myLevel = new \ArrayObject();
2086 
2087  $this->__doChild($myLevel, $this->_signerList, 'signerList', SOAP_ENC_OBJECT, $namespace, 0, 1);
2088  $this->__doChild($myLevel, $this->_type, 'type', 101, $namespace, 0, 1);
2089 
2090  //return $myLevel;
2091  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
2092  }
2093 }
2094 
2095 class signLineList extends SoapObject {
2096  // name="signLine" type="type:signLine"[COMPLEXTYPE] minOccurs="0" maxOccurs="unbounded" nillable="false"
2097  private $_signLine = array();
2098  private $_hasSignLine = false;
2099  public function replaceArraySignLine($value) {
2100  $this->_signLine = $value;
2101  $this->_hasSignLine = (isset($this->_signLine) && !empty($this->_signLine));
2102  }
2103  public function retrieveArraySignLine() {
2104  return $this->_signLine;
2105  }
2106  public function addSignLine($value) {
2107  array_push($this->_signLine, $value);
2108  $this->_hasSignLine = (isset($this->_signLine) && !empty($this->_signLine));
2109  }
2110  public function hasSignLine() {
2111  return $this->_hasSignLine;
2112  }
2113  public function getSignLine($index) {
2114  return $this->_signLine[$index];
2115  }
2116  public function countSignLine() {
2117  return count($this->_signLine);
2118  }
2119 
2120 
2121  static public function fromSoap($vData) {
2122  $newItem = new signLineList();
2123  if (isset($vData['signLine']) && !empty($vData['signLine'])) {
2124  if (SoapObject::is_assoc($vData['signLine'])) {
2125  // Si es asociativo, lo probable es que nos encontremos ante un array de un solo elemento de forma que directamente se ha introducido el elemento a tratar
2126  $newClass = signLine::fromSoap($vData['signLine']);
2127  $newItem->addSignLine($newClass);
2128  } else {
2129  foreach ($vData['signLine'] as $oVar) {
2130  $newClass = signLine::fromSoap($oVar);
2131  $newItem->addSignLine($newClass);
2132  }
2133  }
2134  }
2135 
2136  return $newItem;
2137  }
2138  public function toSoap($fieldName, $namespace) {
2139  $myLevel = new \ArrayObject();
2140 
2141  $this->__doChild($myLevel, $this->_signLine, 'signLine', SOAP_ENC_OBJECT, $namespace, 0, unbounded);
2142 
2143  //return $myLevel;
2144  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
2145  }
2146 }
2147 
2148 class remitterList extends SoapObject {
2149  // name="user" type="type:user"[COMPLEXTYPE] minOccurs="0" maxOccurs="unbounded" nillable="false"
2150  private $_user = array();
2151  private $_hasUser = false;
2152  public function replaceArrayUser($value) {
2153  $this->_user = $value;
2154  $this->_hasUser = (isset($this->_user) && !empty($this->_user));
2155  }
2156  public function retrieveArrayUser() {
2157  return $this->_user;
2158  }
2159  public function addUser($value) {
2160  array_push($this->_user, $value);
2161  $this->_hasUser = (isset($this->_user) && !empty($this->_user));
2162  }
2163  public function hasUser() {
2164  return $this->_hasUser;
2165  }
2166  public function getUser($index) {
2167  return $this->_user[$index];
2168  }
2169  public function countUser() {
2170  return count($this->_user);
2171  }
2172 
2173 
2174  static public function fromSoap($vData) {
2175  $newItem = new remitterList();
2176  if (isset($vData['user']) && !empty($vData['user'])) {
2177  if (SoapObject::is_assoc($vData['user'])) {
2178  // Si es asociativo, lo probable es que nos encontremos ante un array de un solo elemento de forma que directamente se ha introducido el elemento a tratar
2179  $newClass = user::fromSoap($vData['user']);
2180  $newItem->addUser($newClass);
2181  } else {
2182  foreach ($vData['user'] as $oVar) {
2183  $newClass = user::fromSoap($oVar);
2184  $newItem->addUser($newClass);
2185  }
2186  }
2187  }
2188 
2189  return $newItem;
2190  }
2191  public function toSoap($fieldName, $namespace) {
2192  $myLevel = new \ArrayObject();
2193 
2194  $this->__doChild($myLevel, $this->_user, 'user', SOAP_ENC_OBJECT, $namespace, 0, unbounded);
2195 
2196  //return $myLevel;
2197  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
2198  }
2199 }
2200 
2201 class signer extends SoapObject {
2202  // name="userJob" type="type:userJob"[COMPLEXTYPE] minOccurs="0" maxOccurs="1" nillable="true"
2203  private $_userJob = null;
2204  private $_hasUserJob = false;
2205  public function setUserJob($value) {
2206  $this->_userJob = $value;
2207  $this->_hasUserJob = ($value !== null);
2208  }
2209  public function hasUserJob() {
2210  return $this->_hasUserJob;
2211  }
2212  public function getUserJob() {
2213  return $this->_userJob;
2214  }
2215 
2216  // name="state" type="type:state"[COMPLEXTYPE] minOccurs="0" maxOccurs="1" nillable="true"
2217  private $_state = null;
2218  private $_hasState = false;
2219  public function setState($value) {
2220  $this->_state = $value;
2221  $this->_hasState = ($value !== null);
2222  }
2223  public function hasState() {
2224  return $this->_hasState;
2225  }
2226  public function getState() {
2227  return $this->_state;
2228  }
2229 
2230  // name="fstate" type="xsd:dateTime"[107] minOccurs="0" maxOccurs="1" nillable="false"
2231  private $_fstate = null;
2232  private $_hasFstate = false;
2233  public function setFstate($value) {
2234  $this->_fstate = $value;
2235  $this->_hasFstate = ($value !== null);
2236  }
2237  public function hasFstate() {
2238  return $this->_hasFstate;
2239  }
2240  public function getFstate() {
2241  return $this->_fstate;
2242  }
2243 
2244 
2245  static public function fromSoap($vData) {
2246  $newItem = new signer();
2247  if (isset($vData['userJob'])) {
2248  $newClass = userJob::fromSoap($vData['userJob']);
2249  $newItem->setUserJob($newClass);
2250  }
2251  if (isset($vData['state'])) {
2252  $newClass = state::fromSoap($vData['state']);
2253  $newItem->setState($newClass);
2254  }
2255  if (isset($vData['fstate'])) {
2256  $newItem->setFstate($vData['fstate']);
2257  }
2258 
2259  return $newItem;
2260  }
2261  public function toSoap($fieldName, $namespace) {
2262  $myLevel = new \ArrayObject();
2263 
2264  $this->__doChild($myLevel, $this->_userJob, 'userJob', SOAP_ENC_OBJECT, $namespace, 0, 1);
2265  $this->__doChild($myLevel, $this->_state, 'state', SOAP_ENC_OBJECT, $namespace, 0, 1);
2266  $this->__doChild($myLevel, $this->_fstate, 'fstate', 107, $namespace, 0, 1);
2267 
2268  //return $myLevel;
2269  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
2270  }
2271 }
2272 
2273 class signerList extends SoapObject {
2274  // name="signer" type="type:signer"[COMPLEXTYPE] minOccurs="0" maxOccurs="unbounded" nillable="false"
2275  private $_signer = array();
2276  private $_hasSigner = false;
2277  public function replaceArraySigner($value) {
2278  $this->_signer = $value;
2279  $this->_hasSigner = (isset($this->_signer) && !empty($this->_signer));
2280  }
2281  public function retrieveArraySigner() {
2282  return $this->_signer;
2283  }
2284  public function addSigner($value) {
2285  array_push($this->_signer, $value);
2286  $this->_hasSigner = (isset($this->_signer) && !empty($this->_signer));
2287  }
2288  public function hasSigner() {
2289  return $this->_hasSigner;
2290  }
2291  public function getSigner($index) {
2292  return $this->_signer[$index];
2293  }
2294  public function countSigner() {
2295  return count($this->_signer);
2296  }
2297 
2298 
2299  static public function fromSoap($vData) {
2300  $newItem = new signerList();
2301  if (isset($vData['signer']) && !empty($vData['signer'])) {
2302  if (SoapObject::is_assoc($vData['signer'])) {
2303  // Si es asociativo, lo probable es que nos encontremos ante un array de un solo elemento de forma que directamente se ha introducido el elemento a tratar
2304  $newClass = signer::fromSoap($vData['signer']);
2305  $newItem->addSigner($newClass);
2306  } else {
2307  foreach ($vData['signer'] as $oVar) {
2308  $newClass = signer::fromSoap($oVar);
2309  $newItem->addSigner($newClass);
2310  }
2311  }
2312  }
2313 
2314  return $newItem;
2315  }
2316  public function toSoap($fieldName, $namespace) {
2317  $myLevel = new \ArrayObject();
2318 
2319  $this->__doChild($myLevel, $this->_signer, 'signer', SOAP_ENC_OBJECT, $namespace, 0, unbounded);
2320 
2321  //return $myLevel;
2322  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
2323  }
2324 }
2325 
2326 class parameterList extends SoapObject {
2327  // name="parameter" type="type:parameter"[COMPLEXTYPE] minOccurs="0" maxOccurs="unbounded" nillable="false"
2328  private $_parameter = array();
2329  private $_hasParameter = false;
2330  public function replaceArrayParameter($value) {
2331  $this->_parameter = $value;
2332  $this->_hasParameter = (isset($this->_parameter) && !empty($this->_parameter));
2333  }
2334  public function retrieveArrayParameter() {
2335  return $this->_parameter;
2336  }
2337  public function addParameter($value) {
2338  array_push($this->_parameter, $value);
2339  $this->_hasParameter = (isset($this->_parameter) && !empty($this->_parameter));
2340  }
2341  public function hasParameter() {
2342  return $this->_hasParameter;
2343  }
2344  public function getParameter($index) {
2345  return $this->_parameter[$index];
2346  }
2347  public function countParameter() {
2348  return count($this->_parameter);
2349  }
2350 
2351 
2352  static public function fromSoap($vData) {
2353  $newItem = new parameterList();
2354  if (isset($vData['parameter']) && !empty($vData['parameter'])) {
2355  if (SoapObject::is_assoc($vData['parameter'])) {
2356  // Si es asociativo, lo probable es que nos encontremos ante un array de un solo elemento de forma que directamente se ha introducido el elemento a tratar
2357  $newClass = parameter::fromSoap($vData['parameter']);
2358  $newItem->addParameter($newClass);
2359  } else {
2360  foreach ($vData['parameter'] as $oVar) {
2361  $newClass = parameter::fromSoap($oVar);
2362  $newItem->addParameter($newClass);
2363  }
2364  }
2365  }
2366 
2367  return $newItem;
2368  }
2369  public function toSoap($fieldName, $namespace) {
2370  $myLevel = new \ArrayObject();
2371 
2372  $this->__doChild($myLevel, $this->_parameter, 'parameter', SOAP_ENC_OBJECT, $namespace, 0, unbounded);
2373 
2374  //return $myLevel;
2375  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
2376  }
2377 }
2378 
2379 class noticeList extends SoapObject {
2380  // name="state" type="type:state"[COMPLEXTYPE] minOccurs="0" maxOccurs="unbounded" nillable="false"
2381  private $_state = array();
2382  private $_hasState = false;
2383  public function replaceArrayState($value) {
2384  $this->_state = $value;
2385  $this->_hasState = (isset($this->_state) && !empty($this->_state));
2386  }
2387  public function retrieveArrayState() {
2388  return $this->_state;
2389  }
2390  public function addState($value) {
2391  array_push($this->_state, $value);
2392  $this->_hasState = (isset($this->_state) && !empty($this->_state));
2393  }
2394  public function hasState() {
2395  return $this->_hasState;
2396  }
2397  public function getState($index) {
2398  return $this->_state[$index];
2399  }
2400  public function countState() {
2401  return count($this->_state);
2402  }
2403 
2404 
2405  static public function fromSoap($vData) {
2406  $newItem = new noticeList();
2407  if (isset($vData['state']) && !empty($vData['state'])) {
2408  if (SoapObject::is_assoc($vData['state'])) {
2409  // Si es asociativo, lo probable es que nos encontremos ante un array de un solo elemento de forma que directamente se ha introducido el elemento a tratar
2410  $newClass = state::fromSoap($vData['state']);
2411  $newItem->addState($newClass);
2412  } else {
2413  foreach ($vData['state'] as $oVar) {
2414  $newClass = state::fromSoap($oVar);
2415  $newItem->addState($newClass);
2416  }
2417  }
2418  }
2419 
2420  return $newItem;
2421  }
2422  public function toSoap($fieldName, $namespace) {
2423  $myLevel = new \ArrayObject();
2424 
2425  $this->__doChild($myLevel, $this->_state, 'state', SOAP_ENC_OBJECT, $namespace, 0, unbounded);
2426 
2427  //return $myLevel;
2428  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
2429  }
2430 }
2431 
2432 class CPFaction extends SoapObject {
2433  // name="state" type="type:state"[COMPLEXTYPE] minOccurs="0" maxOccurs="1" nillable="true"
2434  private $_state = null;
2435  private $_hasState = false;
2436  public function setState($value) {
2437  $this->_state = $value;
2438  $this->_hasState = ($value !== null);
2439  }
2440  public function hasState() {
2441  return $this->_hasState;
2442  }
2443  public function getState() {
2444  return $this->_state;
2445  }
2446 
2447  // name="action" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
2448  private $_action = null;
2449  private $_hasAction = false;
2450  public function setAction($value) {
2451  $this->_action = $value;
2452  $this->_hasAction = ($value !== null);
2453  }
2454  public function hasAction() {
2455  return $this->_hasAction;
2456  }
2457  public function getAction() {
2458  return $this->_action;
2459  }
2460 
2461  // name="type" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
2462  private $_type = null;
2463  private $_hasType = false;
2464  public function setType($value) {
2465  $this->_type = $value;
2466  $this->_hasType = ($value !== null);
2467  }
2468  public function hasType() {
2469  return $this->_hasType;
2470  }
2471  public function getType() {
2472  return $this->_type;
2473  }
2474 
2475 
2476  static public function fromSoap($vData) {
2477  $newItem = new CPFaction();
2478  if (isset($vData['state'])) {
2479  $newClass = state::fromSoap($vData['state']);
2480  $newItem->setState($newClass);
2481  }
2482  if (isset($vData['action'])) {
2483  $newItem->setAction($vData['action']);
2484  }
2485  if (isset($vData['type'])) {
2486  $newItem->setType($vData['type']);
2487  }
2488 
2489  return $newItem;
2490  }
2491  public function toSoap($fieldName, $namespace) {
2492  $myLevel = new \ArrayObject();
2493 
2494  $this->__doChild($myLevel, $this->_state, 'state', SOAP_ENC_OBJECT, $namespace, 0, 1);
2495  $this->__doChild($myLevel, $this->_action, 'action', 101, $namespace, 0, 1);
2496  $this->__doChild($myLevel, $this->_type, 'type', 101, $namespace, 0, 1);
2497 
2498  //return $myLevel;
2499  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
2500  }
2501 }
2502 
2503 class CPFactionList extends SoapObject {
2504  // name="action" type="type:action"[COMPLEXTYPE] minOccurs="0" maxOccurs="unbounded" nillable="false"
2505  private $_action = array();
2506  private $_hasAction = false;
2507  public function replaceArrayAction($value) {
2508  $this->_action = $value;
2509  $this->_hasAction = (isset($this->_action) && !empty($this->_action));
2510  }
2511  public function retrieveArrayAction() {
2512  return $this->_action;
2513  }
2514  public function addAction($value) {
2515  array_push($this->_action, $value);
2516  $this->_hasAction = (isset($this->_action) && !empty($this->_action));
2517  }
2518  public function hasAction() {
2519  return $this->_hasAction;
2520  }
2521  public function getAction($index) {
2522  return $this->_action[$index];
2523  }
2524  public function countAction() {
2525  return count($this->_action);
2526  }
2527 
2528 
2529  static public function fromSoap($vData) {
2530  $newItem = new CPFactionList();
2531  if (isset($vData['action']) && !empty($vData['action'])) {
2532  if (SoapObject::is_assoc($vData['action'])) {
2533  // Si es asociativo, lo probable es que nos encontremos ante un array de un solo elemento de forma que directamente se ha introducido el elemento a tratar
2534  $newClass = CPFaction::fromSoap($vData['action']);
2535  $newItem->addAction($newClass);
2536  } else {
2537  foreach ($vData['action'] as $oVar) {
2538  $newClass = CPFaction::fromSoap($oVar);
2539  $newItem->addAction($newClass);
2540  }
2541  }
2542  }
2543 
2544  return $newItem;
2545  }
2546  public function toSoap($fieldName, $namespace) {
2547  $myLevel = new \ArrayObject();
2548 
2549  $this->__doChild($myLevel, $this->_action, 'action', SOAP_ENC_OBJECT, $namespace, 0, unbounded);
2550 
2551  //return $myLevel;
2552  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
2553  }
2554 }
2555 
2556 class comment extends SoapObject {
2557  // name="subject" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="false"
2558  private $_subject = null;
2559  private $_hasSubject = false;
2560  public function setSubject($value) {
2561  $this->_subject = $value;
2562  $this->_hasSubject = ($value !== null);
2563  }
2564  public function hasSubject() {
2565  return $this->_hasSubject;
2566  }
2567  public function getSubject() {
2568  return $this->_subject;
2569  }
2570 
2571  // name="textComment" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="false"
2572  private $_textComment = null;
2573  private $_hasTextComment = false;
2574  public function setTextComment($value) {
2575  $this->_textComment = $value;
2576  $this->_hasTextComment = ($value !== null);
2577  }
2578  public function hasTextComment() {
2579  return $this->_hasTextComment;
2580  }
2581  public function getTextComment() {
2582  return $this->_textComment;
2583  }
2584 
2585  // name="fmodify" type="xsd:dateTime"[107] minOccurs="0" maxOccurs="1" nillable="false"
2586  private $_fmodify = null;
2587  private $_hasFmodify = false;
2588  public function setFmodify($value) {
2589  $this->_fmodify = $value;
2590  $this->_hasFmodify = ($value !== null);
2591  }
2592  public function hasFmodify() {
2593  return $this->_hasFmodify;
2594  }
2595  public function getFmodify() {
2596  return $this->_fmodify;
2597  }
2598 
2599  // name="user" type="type:userJob"[COMPLEXTYPE] minOccurs="0" maxOccurs="1" nillable="false"
2600  private $_user = null;
2601  private $_hasUser = false;
2602  public function setUser($value) {
2603  $this->_user = $value;
2604  $this->_hasUser = ($value !== null);
2605  }
2606  public function hasUser() {
2607  return $this->_hasUser;
2608  }
2609  public function getUser() {
2610  return $this->_user;
2611  }
2612 
2613 
2614  static public function fromSoap($vData) {
2615  $newItem = new comment();
2616  if (isset($vData['subject'])) {
2617  $newItem->setSubject($vData['subject']);
2618  }
2619  if (isset($vData['textComment'])) {
2620  $newItem->setTextComment($vData['textComment']);
2621  }
2622  if (isset($vData['fmodify'])) {
2623  $newItem->setFmodify($vData['fmodify']);
2624  }
2625  if (isset($vData['user'])) {
2626  $newClass = user::fromSoap($vData['user']);
2627  $newItem->setUser($newClass);
2628  }
2629 
2630  return $newItem;
2631  }
2632  public function toSoap($fieldName, $namespace) {
2633  $myLevel = new \ArrayObject();
2634 
2635  $this->__doChild($myLevel, $this->_subject, 'subject', 101, $namespace, 0, 1);
2636  $this->__doChild($myLevel, $this->_textComment, 'textComment', 101, $namespace, 0, 1);
2637  $this->__doChild($myLevel, $this->_fmodify, 'fmodify', 107, $namespace, 0, 1);
2638  $this->__doChild($myLevel, $this->_user, 'user', SOAP_ENC_OBJECT, $namespace, 0, 1);
2639 
2640  //return $myLevel;
2641  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
2642  }
2643 }
2644 
2645 class commentList extends SoapObject {
2646  // name="comment" type="type:comment"[COMPLEXTYPE] minOccurs="0" maxOccurs="unbounded" nillable="false"
2647  private $_comment = array();
2648  private $_hasComment = false;
2649  public function replaceArrayComment($value) {
2650  $this->_comment = $value;
2651  $this->_hasComment = (isset($this->_comment) && !empty($this->_comment));
2652  }
2653  public function retrieveArrayComment() {
2654  return $this->_comment;
2655  }
2656  public function addComment($value) {
2657  array_push($this->_comment, $value);
2658  $this->_hasComment = (isset($this->_comment) && !empty($this->_comment));
2659  }
2660  public function hasComment() {
2661  return $this->_hasComment;
2662  }
2663  public function getComment($index) {
2664  return $this->_comment[$index];
2665  }
2666  public function countComment() {
2667  return count($this->_comment);
2668  }
2669 
2670 
2671  static public function fromSoap($vData) {
2672  $newItem = new commentList();
2673  if (isset($vData['comment']) && !empty($vData['comment'])) {
2674  if (SoapObject::is_assoc($vData['comment'])) {
2675  // Si es asociativo, lo probable es que nos encontremos ante un array de un solo elemento de forma que directamente se ha introducido el elemento a tratar
2676  $newClass = comment::fromSoap($vData['comment']);
2677  $newItem->addComment($newClass);
2678  } else {
2679  foreach ($vData['comment'] as $oVar) {
2680  $newClass = comment::fromSoap($oVar);
2681  $newItem->addComment($newClass);
2682  }
2683  }
2684  }
2685 
2686  return $newItem;
2687  }
2688  public function toSoap($fieldName, $namespace) {
2689  $myLevel = new \ArrayObject();
2690 
2691  $this->__doChild($myLevel, $this->_comment, 'comment', SOAP_ENC_OBJECT, $namespace, 0, unbounded);
2692 
2693  //return $myLevel;
2694  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
2695  }
2696 }
2697 
2699  // name="userName" type="xsd:string"[101] minOccurs="1" maxOccurs="1" nillable="false"
2700  private $_userName = null;
2701  private $_hasUserName = false;
2702  public function setUserName($value) {
2703  $this->_userName = $value;
2704  $this->_hasUserName = ($value !== null);
2705  }
2706  public function hasUserName() {
2707  return $this->_hasUserName;
2708  }
2709  public function getUserName() {
2710  return $this->_userName;
2711  }
2712 
2713  // name="password" type="xsd:string"[101] minOccurs="1" maxOccurs="1" nillable="false"
2714  private $_password = null;
2715  private $_hasPassword = false;
2716  public function setPassword($value) {
2717  $this->_password = $value;
2718  $this->_hasPassword = ($value !== null);
2719  }
2720  public function hasPassword() {
2721  return $this->_hasPassword;
2722  }
2723  public function getPassword() {
2724  return $this->_password;
2725  }
2726 
2727 
2728  static public function fromSoap($vData) {
2729  $newItem = new authentication();
2730  if (!isset($vData['userName'])) {
2731  throw new \Exception('El parametro userName es obligatorio');
2732  }
2733  if (isset($vData['userName'])) {
2734  $newItem->setUserName($vData['userName']);
2735  }
2736  if (!isset($vData['password'])) {
2737  throw new \Exception('El parametro password es obligatorio');
2738  }
2739  if (isset($vData['password'])) {
2740  $newItem->setPassword($vData['password']);
2741  }
2742 
2743  return $newItem;
2744  }
2745  public function toSoap($fieldName, $namespace) {
2746  $myLevel = new \ArrayObject();
2747 
2748  $this->__doChild($myLevel, $this->_userName, 'userName', 101, $namespace, 1, 1);
2749  $this->__doChild($myLevel, $this->_password, 'password', 101, $namespace, 1, 1);
2750 
2751  //return $myLevel;
2752  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
2753  }
2754 }
2755 
2756 class signature extends SoapObject {
2757  // name="identifier" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
2758  private $_identifier = null;
2759  private $_hasIdentifier = false;
2760  public function setIdentifier($value) {
2761  $this->_identifier = $value;
2762  $this->_hasIdentifier = ($value !== null);
2763  }
2764  public function hasIdentifier() {
2765  return $this->_hasIdentifier;
2766  }
2767  public function getIdentifier() {
2768  return $this->_identifier;
2769  }
2770 
2771  // name="sign" type="xsd:boolean"[102] minOccurs="0" maxOccurs="1" nillable="true"
2772  private $_sign = null;
2773  private $_hasSign = false;
2774  public function setSign($value) {
2775  $this->_sign = $value;
2776  $this->_hasSign = ($value !== null);
2777  }
2778  public function hasSign() {
2779  return $this->_hasSign;
2780  }
2781  public function getSign() {
2782  return $this->_sign;
2783  }
2784 
2785  // name="signFormat" type="type:signFormat"[101] minOccurs="0" maxOccurs="1" nillable="true"
2786  private $_signFormat = null;
2787  private $_hasSignFormat = false;
2788  public function setSignFormat($value) {
2789  $this->_signFormat = $value;
2790  $this->_hasSignFormat = ($value !== null);
2791  }
2792  public function hasSignFormat() {
2793  return $this->_hasSignFormat;
2794  }
2795  public function getSignFormat() {
2796  return $this->_signFormat;
2797  }
2798 
2799  // name="csv" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
2800  private $_csv = null;
2801  private $_hasCsv = false;
2802  public function setCsv($value) {
2803  $this->_csv = $value;
2804  $this->_hasCsv = ($value !== null);
2805  }
2806  public function hasCsv() {
2807  return $this->_hasCsv;
2808  }
2809  public function getCsv() {
2810  return $this->_csv;
2811  }
2812 
2813  // name="csvAnulado" type="xsd:boolean"[102] minOccurs="0" maxOccurs="1" nillable="true"
2814  private $_csvAnulado = null;
2815  private $_hasCsvAnulado = false;
2816  public function setCsvAnulado($value) {
2817  $this->_csvAnulado = $value;
2818  $this->_hasCsvAnulado = ($value !== null);
2819  }
2820  public function hasCsvAnulado() {
2821  return $this->_hasCsvAnulado;
2822  }
2823  public function getCsvAnulado() {
2824  return $this->_csvAnulado;
2825  }
2826 
2827  // name="csvNormativa" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
2828  private $_csvNormativa = null;
2829  private $_hasCsvNormativa = false;
2830  public function setCsvNormativa($value) {
2831  $this->_csvNormativa = $value;
2832  $this->_hasCsvNormativa = ($value !== null);
2833  }
2834  public function hasCsvNormativa() {
2835  return $this->_hasCsvNormativa;
2836  }
2837  public function getCsvNormativa() {
2838  return $this->_csvNormativa;
2839  }
2840 
2841  // name="content" type="xsd:base64Binary"[116] minOccurs="0" maxOccurs="1" nillable="true"
2842  private $_content = null;
2843  private $_hasContent = false;
2844  public function setContent($value) {
2845  $this->_content = $value;
2846  $this->_hasContent = ($value !== null);
2847  }
2848  public function hasContent() {
2849  return $this->_hasContent;
2850  }
2851  public function getContent() {
2852  return $this->_content;
2853  }
2854 
2855 
2856  static public function fromSoap($vData) {
2857  $newItem = new signature();
2858  if (isset($vData['identifier'])) {
2859  $newItem->setIdentifier($vData['identifier']);
2860  }
2861  if (isset($vData['sign'])) {
2862  $newItem->setSign($vData['sign']);
2863  }
2864  if (isset($vData['signFormat'])) {
2865  $newItem->setSignFormat($vData['signFormat']);
2866  }
2867  if (isset($vData['csv'])) {
2868  $newItem->setCsv($vData['csv']);
2869  }
2870  if (isset($vData['csvAnulado'])) {
2871  $newItem->setCsvAnulado($vData['csvAnulado']);
2872  }
2873  if (isset($vData['csvNormativa'])) {
2874  $newItem->setCsvNormativa($vData['csvNormativa']);
2875  }
2876  if (isset($vData['content'])) {
2877  $newItem->setContent($vData['content']);
2878  }
2879 
2880  return $newItem;
2881  }
2882  public function toSoap($fieldName, $namespace) {
2883  $myLevel = new \ArrayObject();
2884 
2885  $this->__doChild($myLevel, $this->_identifier, 'identifier', 101, $namespace, 0, 1);
2886  $this->__doChild($myLevel, $this->_sign, 'sign', 102, $namespace, 0, 1);
2887  $this->__doChild($myLevel, $this->_signFormat, 'signFormat', 101, $namespace, 0, 1);
2888  $this->__doChild($myLevel, $this->_csv, 'csv', 101, $namespace, 0, 1);
2889  $this->__doChild($myLevel, $this->_csvAnulado, 'csvAnulado', 102, $namespace, 0, 1);
2890  $this->__doChild($myLevel, $this->_csvNormativa, 'csvNormativa', 101, $namespace, 0, 1);
2891  $this->__doChild($myLevel, $this->_content, 'content', 116, $namespace, 0, 1);
2892 
2893  //return $myLevel;
2894  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
2895  }
2896 }
2897 
2898 class signatureRef extends SoapObject {
2899  // name="identifier" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
2900  private $_identifier = null;
2901  private $_hasIdentifier = false;
2902  public function setIdentifier($value) {
2903  $this->_identifier = $value;
2904  $this->_hasIdentifier = ($value !== null);
2905  }
2906  public function hasIdentifier() {
2907  return $this->_hasIdentifier;
2908  }
2909  public function getIdentifier() {
2910  return $this->_identifier;
2911  }
2912 
2913  // name="sign" type="xsd:boolean"[102] minOccurs="0" maxOccurs="1" nillable="true"
2914  private $_sign = null;
2915  private $_hasSign = false;
2916  public function setSign($value) {
2917  $this->_sign = $value;
2918  $this->_hasSign = ($value !== null);
2919  }
2920  public function hasSign() {
2921  return $this->_hasSign;
2922  }
2923  public function getSign() {
2924  return $this->_sign;
2925  }
2926 
2927  // name="signFormat" type="type:signFormat"[101] minOccurs="0" maxOccurs="1" nillable="true"
2928  private $_signFormat = null;
2929  private $_hasSignFormat = false;
2930  public function setSignFormat($value) {
2931  $this->_signFormat = $value;
2932  $this->_hasSignFormat = ($value !== null);
2933  }
2934  public function hasSignFormat() {
2935  return $this->_hasSignFormat;
2936  }
2937  public function getSignFormat() {
2938  return $this->_signFormat;
2939  }
2940 
2941  // name="csv" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
2942  private $_csv = null;
2943  private $_hasCsv = false;
2944  public function setCsv($value) {
2945  $this->_csv = $value;
2946  $this->_hasCsv = ($value !== null);
2947  }
2948  public function hasCsv() {
2949  return $this->_hasCsv;
2950  }
2951  public function getCsv() {
2952  return $this->_csv;
2953  }
2954 
2955  // name="csvAnulado" type="xsd:boolean"[102] minOccurs="0" maxOccurs="1" nillable="true"
2956  private $_csvAnulado = null;
2957  private $_hasCsvAnulado = false;
2958  public function setCsvAnulado($value) {
2959  $this->_csvAnulado = $value;
2960  $this->_hasCsvAnulado = ($value !== null);
2961  }
2962  public function hasCsvAnulado() {
2963  return $this->_hasCsvAnulado;
2964  }
2965  public function getCsvAnulado() {
2966  return $this->_csvAnulado;
2967  }
2968 
2969  // name="csvNormativa" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
2970  private $_csvNormativa = null;
2971  private $_hasCsvNormativa = false;
2972  public function setCsvNormativa($value) {
2973  $this->_csvNormativa = $value;
2974  $this->_hasCsvNormativa = ($value !== null);
2975  }
2976  public function hasCsvNormativa() {
2977  return $this->_hasCsvNormativa;
2978  }
2979  public function getCsvNormativa() {
2980  return $this->_csvNormativa;
2981  }
2982 
2983  // name="gde" type="xsd:string"[101] minOccurs="0" maxOccurs="1" nillable="true"
2984  private $_gde = null;
2985  private $_hasGde = false;
2986  public function setGde($value) {
2987  $this->_gde = $value;
2988  $this->_hasGde = ($value !== null);
2989  }
2990  public function hasGde() {
2991  return $this->_hasGde;
2992  }
2993  public function getGde() {
2994  return $this->_gde;
2995  }
2996 
2997 
2998  static public function fromSoap($vData) {
2999  $newItem = new signatureRef();
3000  if (isset($vData['identifier'])) {
3001  $newItem->setIdentifier($vData['identifier']);
3002  }
3003  if (isset($vData['sign'])) {
3004  $newItem->setSign($vData['sign']);
3005  }
3006  if (isset($vData['signFormat'])) {
3007  $newItem->setSignFormat($vData['signFormat']);
3008  }
3009  if (isset($vData['csv'])) {
3010  $newItem->setCsv($vData['csv']);
3011  }
3012  if (isset($vData['csvAnulado'])) {
3013  $newItem->setCsvAnulado($vData['csvAnulado']);
3014  }
3015  if (isset($vData['csvNormativa'])) {
3016  $newItem->setCsvNormativa($vData['csvNormativa']);
3017  }
3018  if (isset($vData['gde'])) {
3019  $newItem->setGde($vData['gde']);
3020  }
3021 
3022  return $newItem;
3023  }
3024  public function toSoap($fieldName, $namespace) {
3025  $myLevel = new \ArrayObject();
3026 
3027  $this->__doChild($myLevel, $this->_identifier, 'identifier', 101, $namespace, 0, 1);
3028  $this->__doChild($myLevel, $this->_sign, 'sign', 102, $namespace, 0, 1);
3029  $this->__doChild($myLevel, $this->_signFormat, 'signFormat', 101, $namespace, 0, 1);
3030  $this->__doChild($myLevel, $this->_csv, 'csv', 101, $namespace, 0, 1);
3031  $this->__doChild($myLevel, $this->_csvAnulado, 'csvAnulado', 102, $namespace, 0, 1);
3032  $this->__doChild($myLevel, $this->_csvNormativa, 'csvNormativa', 101, $namespace, 0, 1);
3033  $this->__doChild($myLevel, $this->_gde, 'gde', 101, $namespace, 0, 1);
3034 
3035  //return $myLevel;
3036  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
3037  }
3038 }
3039 
3040 class timestampInfo extends SoapObject {
3041  // name="addTimestamp" type="xsd:boolean"[102] minOccurs="0" maxOccurs="1" nillable="false"
3042  private $_addTimestamp = null;
3043  private $_hasAddTimestamp = false;
3044  public function setAddTimestamp($value) {
3045  $this->_addTimestamp = $value;
3046  $this->_hasAddTimestamp = ($value !== null);
3047  }
3048  public function hasAddTimestamp() {
3049  return $this->_hasAddTimestamp;
3050  }
3051  public function getAddTimestamp() {
3052  return $this->_addTimestamp;
3053  }
3054 
3055 
3056  static public function fromSoap($vData) {
3057  $newItem = new timestampInfo();
3058  if (isset($vData['addTimestamp'])) {
3059  $newItem->setAddTimestamp($vData['addTimestamp']);
3060  }
3061 
3062  return $newItem;
3063  }
3064  public function toSoap($fieldName, $namespace) {
3065  $myLevel = new \ArrayObject();
3066 
3067  $this->__doChild($myLevel, $this->_addTimestamp, 'addTimestamp', 102, $namespace, 0, 1);
3068 
3069  //return $myLevel;
3070  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
3071  }
3072 }
3073 
3074 class stringList extends SoapObject {
3075  // name="str" type="xsd:string"[101] minOccurs="0" maxOccurs="unbounded" nillable="false"
3076  private $_str = array();
3077  private $_hasStr = false;
3078  public function replaceArrayStr($value) {
3079  $this->_str = $value;
3080  $this->_hasStr = (isset($this->_str) && !empty($this->_str));
3081  }
3082  public function retrieveArrayStr() {
3083  return $this->_str;
3084  }
3085  public function addStr($value) {
3086  array_push($this->_str, $value);
3087  $this->_hasStr = (isset($this->_str) && !empty($this->_str));
3088  }
3089  public function hasStr() {
3090  return $this->_hasStr;
3091  }
3092  public function getStr($index) {
3093  return $this->_str[$index];
3094  }
3095  public function countStr() {
3096  return count($this->_str);
3097  }
3098 
3099 
3100  static public function fromSoap($vData) {
3101  $newItem = new stringList();
3102  if (isset($vData['str']) && !empty($vData['str'])) {
3103  if (SoapObject::is_assoc($vData['str'])) {
3104  // Si es asociativo, lo probable es que nos encontremos ante un array de un solo elemento de forma que directamente se ha introducido el elemento a tratar
3105  $newItem->addStr($vData['str']);
3106  } else {
3107  $newItem->replaceAllStr($vData['str']);
3108  }
3109  }
3110 
3111  return $newItem;
3112  }
3113  public function toSoap($fieldName, $namespace) {
3114  $myLevel = new \ArrayObject();
3115 
3116  $this->__doChild($myLevel, $this->_str, 'str', 101, $namespace, 0, unbounded);
3117 
3118  //return $myLevel;
3119  return new \SoapVar($myLevel, SOAP_ENC_OBJECT, null, null, $fieldName, $namespace);
3120  }
3121 }
3122 
3123 ?>