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