?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Tiny hack to make $course work OK in file resources (print_header)
[moodle.git] / mod / scorm / validatordomxml.php
blob54c4ad21adb98e13f745f58e36c11feead64ab5e
1 <?php
2
3 define("01", "useCurrentAttemptObjectiveInfo");
4 define("02", "useCurrentAttemptProgressInfo");
5
6 $cont_err = 0; //contatore per il numero di eventuali errori
7 $errors = array(); //array degli errori
8 $item_idref_array = array(); //array degli attr. idRef di <item>
9 $idres_array = array(); //array degli attr. id di <resource>
10 $def_org_array = array();
11 $id_org_array = array();
12
13 function is_spec($stringa)
14 {
15 return($stringa == "\n" | $stringa == "\r" | $stringa == "\t" |
16 $stringa == " " | $stringa == "\0" | $stringa == "\x0B"|
17 $stringa == "");
18 }
19
20 // Funzione che ritorna i valori validi per il tag <timeLimitAction>
21
22 function is_message($str)
23 {
24 return($str == "exit,message" | $str = "exit,no message" | $str == "continue,message" |
25 $str == "continue,no message");
26 }
27
28 function is_cond_val($st)
29 {
30 return($st == "satisfied" | $st == "objectiveStatusKnown" | $st == "objectiveMeasureKnown" |
31 $st == "objectiveMeasureGreaterThan" | $st == "objectiveMeasureLessThan" |
32 $st == "completed" | $st =="activityProgressKnown" | $st == "attempted" |
33 $st == "attemptLimitExceeded" | $st == "timeLimitExceeded" | $st == "always" |
34 $st == "outsideAvailableTimeRange");
35 }
36
37 function is_action1($str1)
38 {
39 return($str1 == "skip" | $str1 == "disabled" | $str1 == "hiddenFromChoice" | $str1 == "stopForwardTraversal");
40 }
41
42 function is_action2($str2)
43 {
44 return($str2 == "exitParent" | $str2 == "exitAll" | $str2 == "retry" | $str2 == "retryAll" |
45 $str2 == "continue" | $str2 == "previous");
46 }
47
48 function is_rcond_val($st1)
49 {
50 return($st1 == "satisfied" | $st1 == "objectiveStatusKnown" | $st1 == "objectiveMeasureKnown" |
51 $st1 == "completed" | $st1 =="activityProgressKnown" | $st1 == "attempted" |
52 $st1 == "attemptLimitExceeded" | $st1 == "timeLimitExceeded" | $st1 == "outsideAvailableTimeRange");
53 }
54
55 function is_rolAc_val($str3)
56 {
57 return($str3 == "satisfied" | $str3 == "notSatisfied" | $str3 == "completed" | $str3 == "incomplete");
58 }
59
60 function is_randT_attr($str4)
61 {
62 return($str4 == "never" | $str4 == "once" | $str4 == "onEachNewAttempt");
63 }
64
65 function is_rolCo_val($str5)
66 {
67 return($str5 == "always" | $str5 == "ifAttempted" | $str5 == "ifNotSkipped" | $str5 == "ifNotSuspended");
68 }
69
70 function is_hch_cont($str6)
71 {
72 return($str6 == "previous" | $str6 == "continue" | $str6 == "exit" | $str6 == "abandon");
73 }
74
75 /* Funzione che testa l'elemento root dell'albero DOM generato */
76
77 function testRoot($DomNode)
78 {
79 global $errors;
80 global $cont_err;
81 $error = NULL;
82
83 if(($DomNode->node_type() == "1")&&($DomNode->tagname() == "manifest"))
84 {
85 if(!$DomNode->has_attributes())
86 {
87 $error->type = "no_attributes";
88 $error->data->tag = "manifest";
89 array_push($errors, $error);
90 $cont_err++;
91 }
92 $attr_array = $DomNode->attributes();
93 $attr_n = $attr_array[0]->node_name();
94 if($DomNode->has_attribute("identifier"))
95 {
96 if((strcmp("identifier", $attr_n)!=0)||($attr_array[0]->node_value() == ""))
97 {
98 $error->type = "attr_error";
99 $error->data->tag = "manifest";
100 $error->data->attr = $attr_n;
101 array_push($errors, $error);
102 $cont_err++;
103 }
104 } else {
105 $error->type = "missing_attribute";
106 $error->data->tag = "manifest";
107 $error->data->attr = 'identifier';
108 array_push($errors, $error);
109 $cont_err++;
110 }
111
112 if($DomNode->has_attribute("version"))
113 {
114 $version = $attr_array[1]->node_value();
115 if(!eregi("[1-9]\.[0-9]", $version))
116 {
117 $error->type = "attr_error";
118 $error->data->tag = "manifest";
119 $error->data->attr = 'version';
120 array_push($errors, $error);
121 $cont_err++;
122 }
123 } else {
124 $error->type = "missing_attribute";
125 $error->data->tag = "manifest";
126 $error->data->attr = 'version';
127 array_push($errors, $error);
128 $cont_err++;
129 }
130 if(count($errors) > 0)
131 {
132 return false;
133 }
134 else {
135 return true;
136 }
137 }
138 return false;
139 }
140
141 /* funzione che scorre l'albero DOM e valida il documento*/
142 function testNode($DomNode)
143 {
144 global $cont_err; //gli array devono essere dichiarati globali
145 global $errors;
146 global $item_idref_array;
147 global $idres_array;
148 global $def_org_array;
149 global $id_org_array;
150 $error = NULL;
151 $version_value = NULL;
152 $schema_version = NULL;
153
154 if($figlio = $DomNode->first_child())
155 {
156 while($figlio)
157 {
158 if($figlio->node_type() == "1")
159 {
160 //valore booleano che viene restituito dalla funzione se e' tutto corretto
161
162 $nome_figlio = $figlio->node_name();
163 $padre = $figlio->parent_node();
164 $pp = $padre->parent_node();
165
166 if($nome_figlio == "metadata")
167 {
168 if($figlio->has_attributes())
169 {
170 $error->type = "too_many_attributes";
171 $error->data->tag = "metadata";
172 array_push($errors, $error);
173 $cont_err++;
174 }
175
176 $mdata_children = $figlio->child_nodes(); //array dei figli
177 // Il metodo count conta il numero di elementi dell'array e ritorna il numero
178 $tot_children = count($mdata_children);
179
180 if($padre->node_name() == "manifest")
181 {
182 //Si controlla se il tag metadata ha i figli <schema> e <schemaversion>
183 //che devono essere SEMPRE presenti all'interno del manifest.
184 $test_sc = $tot_children;
185 $test_scv = $tot_children;
186 for($i = 0; $i < $tot_children; $i++)
187 {
188 $cur_child = $mdata_children[$i];
189 if($cur_child->node_name()!="schema")
190 {
191 $test_sc--;
192 }
193 if($cur_child->node_name() != "schemaversion")
194 {
195 $test_scv--;
196 } else {
197 $schema_version = $cur_child->node_value();
198 }
199 }
200
201 if(!eregi("(CAM[[:blank:]])?[1]\.[3]", $schema_version))
202 {
203 if($figlio->has_child_nodes())
204 {
205 $error->type = "too_many_children";
206 $error->data->tag = "metadata";
207 array_push($errors, $error);
208 }
209 } else {
210 if(!$figlio->has_child_nodes())
211 {
212 $error->type = "no_children";
213 $error->data->tag = "metadata";
214 array_push($errors, $error);
215 }
216
217 if($test_sc <= 0)
218 {
219 $error->type = "missing_tag";
220 $error->data->tag = "schema";
221 array_push($errors, $error);
222 $cont_err++;
223 }
224 if($test_scv <= 0)
225 {
226 $error->type = "missing_tag";
227 $error->data->tag = "schemaversion";
228 array_push($errors, $error);
229 $cont_err++;
230 }
231 }
232
233 }
234
235 //METADATA puo'comparire anche come figlio di altri nodi
236
237 if($padre->node_name() != "manifest")
238 {
239 $t_sc = $tot_children;
240 $t_scv = $tot_children;
241 $new_t_sc = 0;
242 $new_t_scv = 0;
243 for($i = 0; $i < $tot_children; $i++)
244 {
245 $cc = $mdata_children[$i];
246
247 if($cc->node_name()=="schema")
248 {
249 $new_t_sc = $t_sc-1;
250 }
251 if($cc->node_name() == "schemaversion")
252 {
253 $new_t_scv = $t_scv-1;
254 $schema_version = $cc->node_value();
255 }
256
257 }//fine FOR
258
259 if(eregi("(CAM[[:blank:]])?[1]\.[3]", $schema_version))
260 {
261 if($new_t_sc < $t_sc)
262 {
263 $error->type = "too_many_children";
264 $error->data->tag = "metadata";
265 array_push($errors, $error);
266 //echo "WARNING, se il tag metadata non e' figlio di manifest non deve avere schema
267 // come figlio <br>";
268 //echo "Probabilmente la versione e' antecedente alla 1.3 <br>";
269 }
270 if($new_t_scv < $t_scv)
271 {
272 $error->type = "too_many_children";
273 $error->data->tag = "metadata";
274 array_push($errors, $error);
275 //echo "WARNING, se il tag metadata non e' figlio di manifest, non deve avere schemaversion
276 // come figlio <br>";
277 //echo "Probabilmente la versione e' antecedente alla 1.3 <br>";
278 }
279 }
280 }
281 // echo "SCANSIONE TAG METADATA TERMINATA, OK \n";
282 }// FINE IF METADATA
283
284 if($nome_figlio == "schema")
285 {
286 if($padre->node_name() != "metadata")
287 {
288 $error->type = "position_error";
289 $error->data->tag = "schema";
290 $error->data->parent = $padre->node_name();
291 array_push($errors, $error);
292 //echo "ERROR, schema puo'comparire solo come figlio di metadata";
293 $cont_err++;
294 }
295 if(!$figlio->has_child_nodes())
296 {
297 $error->type = "no_children";
298 $error->data->tag = "schema";
299 array_push($errors, $error);
300 $cont_err++;
301 }
302 $sc = $figlio->first_child();
303 if(($sc->node_type() == 3)&&(strcmp($sc->node_value(), "ADL SCORM")!=0))
304 {
305 $error->type = "tag_error";
306 $error->data->tag = "schema";
307 $error->data->value = $sc->node_value();
308 array_push($errors, $error);
309 $cont_err++;
310 }
311
312 }
313
314 if($nome_figlio == "schemaversion")
315 {
316 if($padre->node_name() != "metadata")
317 {
318 $error->type = "position_error";
319 $error->data->tag = "schemaversion";
320 $error->data->parent = $padre->node_name();
321 array_push($errors, $error);
322 $cont_err++;
323 }
324 if(!$figlio->has_child_nodes())
325 {
326 $error->type = "no_children";
327 $error->data->tag = "schema";
328 array_push($errors, $error);
329 $cont_err++;
330 }
331 $svc = $figlio->first_child();
332
333 $version_value = $svc->node_value();
334 if(($svc->node_type() == 3)&&(!eregi("(CAM[[:blank:]])?[1]\.[0-3]",$svc->node_value())))
335 {
336 $version_value = $svc->node_value();
337 if(eregi("[1]\.[0-3]", $version_value))
338 {
339 echo "Versione=",$version_value;
340 } else {
341 $error->type = "tag_error";
342 $error->data->tag = "schemaversion";
343 $error->data->value = $version_value;
344 array_push($errors, $error);
345 }
346 }
347
348 }
349
350 if($nome_figlio == "location")
351 {
352 if(strcmp("metadata", $padre->node_name())!=0)
353 {
354 $error->type = "position_error";
355 $error->data->tag = "location";
356 $error->data->parent = $padre->node_name();
357 array_push($errors, $error);
358 $cont_err++;
359 }
360 if(!$figlio->has_child_nodes())
361 {
362 $error->type = "no_children";
363 $error->data->tag = "location";
364 array_push($errors, $error);
365 $cont_err++;
366 }
367 else
368 {
369 $loc = $figlio->first_child();
370 if(($loc->node_type() == 3)&&(!eregi("[[:print:]]\.[a-z]",$loc->node_value())))
371 {
372 $error->type = "tag_error";
373 $error->data->tag = "location";
374 $error->data->value = $loc->node_value();
375 array_push($errors, $error);
376 $cont_err++;
377 }
378 }
379 //echo "<br> SCANSIONE DI LOCATION TERMINATA, OK \n";
380 }
381
382 if($nome_figlio == "organizations")
383 {
384 if($padre->node_name() != "manifest")
385 {
386 $error->type = "position_error";
387 $error->data->tag = "organizations";
388 $error->data->parent = $padre->node_name();
389 array_push($errors, $error);
390 $cont_err++;
391 }
392 if(!eregi("(CAM[[:blank:]])?[1]\.[3]", $version_value))
393 {
394 if($figlio->has_attribute("default"))
395 {
396 $orgs_attr_old = $figlio->attributes();
397 $defv_old = $orgs_attr_old[0]->node_value();
398 if(!eregi("[[:graph:]]", $defv_old))
399 {
400 $error->type = "attr_error";
401 $error->data->tag = "organizations";
402 $error->data->attr = "default";
403 array_push($errors, $error);
404 $cont_err++;
405 }
406 }
407 } else {
408 if((!$figlio->has_attributes())||(!$figlio->has_attribute("default")))
409 {
410 $error->type = "missing_attribute";
411 $error->data->tag = "organizations";
412 $error->data->attr = "default";
413 array_push($errors, $error);
414 $cont_err++;
415 }
416 $orgs_attr = $figlio->attributes();
417 if($orgs_attr[0]->node_value() != "")
418 {
419 $def_v = $orgs_attr[0]->node_value();
420 array_push($def_org_array, $def_v);
421 }
422
423 if(!$figlio->has_child_nodes())
424 {
425 $error->type = "no_children";
426 $error->data->tag = "organizations";
427 array_push($errors, $error);
428 $cont_err++;
429 }
430
431 $orgs_children = $figlio->child_nodes();
432 $cont_orgs = count($orgs_children);
433
434 for($k=0; $k < $cont_orgs; $k++)
435 {
436 $co = $orgs_children[$k];
437 $test1 = $cont_orgs;
438 if(($co->node_type() != 1)&&($co->node_name() != "organization"))
439 {
440 $test1--;
441 }
442 }
443
444 if($test1 <= 0)
445 {
446 $error->type = "missing_tag";
447 $error->data->tag = "organizations";
448 array_push($errors, $error);
449 $cont_err++;
450 }
451 }
452
453 //echo "SCANSIONE TAG ORGANIZATIONS TERMINATA, OK \n";
454 }//FINE IF ORGANIZATIONS
455
456 if($nome_figlio == "organization")
457 {
458 if($padre->node_name() != "organizations")
459 {
460 $error->type = "position_error";
461 $error->data->tag = "organization";
462 $error->data->parent = $padre->node_name();
463 array_push($errors, $error);
464 $cont_err++;
465 }
466
467 if(!$figlio->has_attributes())
468 {
469 $error->type = "no_attributes";
470 $error->data->tag = "organization";
471 array_push($errors, $error);
472 $cont_err++;
473 }
474 $org_attr = $figlio->attributes();
475 $cont_org = count($org_attr);
476 if($cont_org > 3)
477 {
478 $error->type = "too_many_attributes";
479 $error->data->tag = "organization";
480 array_push($errors, $error);
481 $cont_err++;
482 }
483 $org_id = $org_attr[0]->node_name();
484 $org_val = $org_attr[0]->node_value();
485 if(($org_id != "identifier")||(!eregi("[[:graph:]]", $org_val)))
486 {
487 $error->type = "attr_error";
488 $error->data->tag = "organization";
489 $error->data->attr = $org_id;
490 array_push($errors, $error);
491 $cont_err++;
492 }
493 else {
494 array_push($id_org_array, $org_val);
495 }
496
497 if($figlio->has_attribute("structure"))
498 {
499 if($org_attr[1]->node_value() == "")
500 {
501 $error->type = "tag_error";
502 $error->data->tag = "organization";
503 array_push($errors, $error);
504 $cont_err++;
505 }
506 }
507
508 if($figlio->has_attribute("adlseq:objectivesGlobalToSystem"))
509 {
510 $ot_n = $org_attr[2]->node_name();
511 $ot_val = $org_attr[2]->node_value();
512 if(eregi("^$", $ot_val))
513 {
514 $error->type = "attrError";
515 $error->data->tag = "organization";
516 $error->data->attr = $ot_n;
517 array_push($errors, $error);
518 $cont_err++;
519 }
520 if(!((strcmp("true", $ot_val)==0)||(strcmp("false", $ot_val)==0)))
521 {
522 $error->type = "attr_error";
523 $error->data->tag = "organization";
524 $error->data->attr = $ot_n;
525 array_push($errors, $error);
526 $cont_err++;
527 }
528 }
529
530 if(!$figlio->has_child_nodes())
531 {
532 $error->type = "no_children";
533 $error->data->tag = "organization";
534 array_push($errors, $error);
535 $cont_err++;
536 }
537
538 $org_children = $figlio->child_nodes();
539 $org_cont = count($org_children);
540 for($j=0; $j < $org_cont; $j++)
541 {
542 $of = $org_children[$j]->node_name();
543 $test2 = $org_cont;
544 if($of != "title")
545 {
546 $test2--;
547 }
548 }
549 if($test2 <= 0)
550 {
551 $error->type = "missing_tag";
552 $error->data->tag = "title";
553 array_push($errors, $error);
554 $cont_err++;
555 }
556
557 //echo "SCANSIONE TAG ORGANIZATION TERMINATA, OK \n";
558 }//FINE IF ORGANIZATION
559
560 if($nome_figlio == "item")
561 {
562 if(!((strcmp("organization", $padre->node_name())==0)||
563 (strcmp("title", $padre->node_name())==0)||
564 (strcmp("item", $padre->node_name())==0)))
565 {
566 $error->type = "position_error";
567 $error->data->tag = "item";
568 $error->data->parent = $padre->node_name();
569 array_push($errors, $error);
570 $cont_err++;
571 }
572 if(!$figlio->has_attributes())
573 {
574 $error->type = "no_attributes";
575 $error->data->tag = "item";
576 array_push($errors, $error);
577 $cont_err++;
578 }
579 $item_attr = $figlio->attributes();
580 $cont_attr2 = count($item_attr);
581 for($i=0; $i < $cont_attr2; $i++)
582 {
583 $ia = $item_attr[$i];
584 if(!$figlio->has_attribute("identifier"))
585 {
586 echo "ERROR, manca l'attributo ID";
587 $cont_err++;
588 }
589 elseif($ia->node_name()=="identifier")
590 {
591 $item_id = $ia->node_name();
592 $item_id_val = $ia->node_value();
593 if($item_id_val == "")
594 {
595 $error->type = "attr_error";
596 $error->data->tag = "item";
597 $error->data->attr = $item_id;
598 array_push($errors, $error);
599 $cont_err++;
600 }
601 }
602
603 if(($figlio->has_attribute("identifierref"))&&($ia->node_name()=="identifierref"))
604 {
605 $id_ref_val = $ia->node_value();
606 if(eregi("[[:graph:]]", $id_ref_val))
607 {
608 array_push($item_idref_array, $id_ref_val);
609 }
610 else
611 {
612 $error->type = "attr_error";
613 $error->data->tag = "item";
614 $error->data->attr = "identifierref";
615 array_push($errors, $error);
616 $cont_err++;
617 }
618 }
619
620 if(($figlio->has_attribute("isvisible"))&&($ia->node_name()=="isvisible"))
621 {
622 $isv_n = $ia->node_name();
623 $isv_val = $ia->node_value();
624 if(!((strcmp("true", $isv_val)==0)||(strcmp("false", $isv_val)==0)))
625 {
626 $error->type = "attr_error";
627 $error->data->tag = "item";
628 $error->data->attr = $isv_n;
629 array_push($errors, $error);
630 $cont_err++;
631 }
632 }
633
634 if(($figlio->has_attribute("parameters"))&&($ia->node_name()=="parameters"))
635 {
636 $par_n = $ia->node_name();
637 $par_val = $ia->node_value();
638 if(($par_val == "")||($par_val == " "))
639 {
640 $error->type = "attr_error";
641 $error->data->tag = "item";
642 $error->data->attr = $par_n;
643 array_push($errors, $error);
644 $cont_err++;
645 }
646 }
647 }//FINE FOR
648
649 if(!$figlio->has_child_nodes())
650 {
651 $error->type = "no_children";
652 $error->data->tag = "item";
653 array_push($errors, $error);
654 $cont_err++;
655 }
656
657 $item_children = $figlio->child_nodes();
658 $cont_ic = count($item_children);
659 for($c=0; $c < $cont_ic; $c++)
660 {
661 $ic_n = $item_children[$c];
662 $test3 = $cont_ic;
663 if($ic_n->node_name() != "title")
664 {
665 $test3--;
666 }
667 }
668 if($test3 <= 0)
669 {
670 $error->type = "missing_tag";
671 $error->data->tag = "title";
672 array_push($errors, $error);
673 $cont_err++;
674 }
675 }//FINE IF ITEM
676
677 if($nome_figlio == "title")
678 {
679 if($figlio->get_content() == "")
680 {
681 $error->type = "tag_error";
682 $error->data->tag = "title";
683 array_push($errors, $error);
684 $cont_err++;
685 }
686 }
687
688 if($nome_figlio == "timeLimitAction")
689 {
690 if($padre->node_name() != "item")
691 {
692 $error->type = "position_error";
693 $error->data->tag = "timeLimitAction";
694 $error->data->parent = $padre->node_name();
695 array_push($errors, $error);
696 $cont_err++;
697 }
698 if($pp->node_name() != "item")
699 {
700 $error->type = "position_error";
701 $error->data->tag = "timeLimitAction";
702 $error->data->parent = $padre->node_name();
703 array_push($errors, $error);
704 $cont_err++;
705 }
706 if(($figlio->get_content() == "")||(!is_message($figlio->get_content())))
707 {
708 $error->type = "tag_error";
709 $error->data->tag = "timeLimitAction";
710 $error->data->value = $figlio->get_content();
711 array_push($errors, $error);
712 $cont_err++;
713 }
714 }
715
716 if($nome_figlio == "dataFromLMS")
717 {
718 if($padre->node_name() != "item")
719 {
720 $error->type = "position_error";
721 $error->data->tag = $nome_figlio;
722 $error->data->parent = $padre->node_name();
723 array_push($errors, $error);
724 $cont_err++;
725 }
726 if($pp->node_name() != "item")
727 {
728 $error->type = "position_error";
729 $error->data->tag = $nome_figlio;
730 $error->data->parent = $padre->node_name();
731 array_push($errors, $error);
732 $cont_err++;
733 }
734 }
735
736 //Il tag prerequisites e' presente solo nelle versioni precedenti alla 1.3
737
738 if(($nome_figlio == "prerequisites")&&(eregi("(CAM[[:blank:]])?[1]\.[0-2]", $version_value)))
739 {
740 if(strcmp("item", $padre->node_name())!=0)
741 {
742 $error->type = "position_error";
743 $error->data->tag = "$nome_figlio";
744 $error->data->parent = $padre->node_name();
745 array_push($errors);
746 $cont_err++;
747 }
748 if(!$figlio->has_attributes())
749 {
750 $error->type = "no_attributes";
751 $error->data->tag = $nome_figlio;
752 array_push($errors, $error);
753 $cont_err++;
754 }
755 if(!$figlio->has_attribute("type"))
756 {
757 $error->type = "missing_attribute";
758 $error->data->tag = $nome_figlio;
759 $error->data->attr = "type";
760 array_push($errors, $error);
761 $cont_err++;
762 } else {
763 $pre_attr = $figlio->attributes();
764 $pre_attr_n = $pre_attr[0]->node_name();
765 $pre_attr_v = $pre_attr[0]->node_value();
766 if((strcmp("type", $pre_attr_n)==0)&&(strcmp("aicc_script", $pre_attr_v)!=0))
767 {
768 $error->type = "attr_error";
769 $error->data->tag = $nome_figlio;
770 $error->data->attr = $pre_attr_n;
771 array_push($errors, $error);
772 $cont_err++;
773 }
774 }
775 }
776
777 //Il tag maxtimeallowed e' presente solo nelle versioni precedenti alla 1.3
778
779 if(($nome_figlio == "maxtimeallowed")&&(eregi("(CAM[[:blank:]])?[1]\.[0-2]", $version_value)))
780 {
781 if(strcmp("item", $padre->node_name())!=0)
782 {
783 $error->type = "position_error";
784 $error->data->tag = "$nome_figlio";
785 $error->data->parent = $padre->node_name();
786 array_push($errors);
787 $cont_err++;
788 }
789 if(!$figlio->has_child_nodes())
790 {
791 $error->type = "no_children";
792 $error->data->tag = $nome_figlio;
793 array_push($errors, $error);
794 $cont_err++;
795 } else {
796 $mta_child = $figlio->first_child();
797 if(!eregi("([0-9]{2}):([0-9]{2}):([0-9]{2})", $mta_child->get_content()))
798 {
799 $error->type = "tag_error";
800 $error->data->tag = $nome_figlio;
801 array_push($errors, $error);
802 $cont_err++;
803 }
804 }
805 }
806
807 //Il tag masteryscore e' presente solo nelle versioni precedenti alla 1.3
808
809 if(($nome_figlio == "masteryscore")&&(eregi("(CAM[[:blank:]])?[1]\.[0-2]", $version_value)))
810 {
811 if(strcmp("item", $padre->node_name())!=0)
812 {
813 $error->type = "position_error";
814 $error->data->tag = "$nome_figlio";
815 $error->data->parent = $padre->node_name();
816 array_push($errors);
817 $cont_err++;
818 }
819 if(!$figlio->has_child_nodes())
820 {
821 $error->type = "no_children";
822 $error->data->tag = $nome_figlio;
823 array_push($errors, $error);
824 $cont_err++;
825 } else {
826 $mta_child = $figlio->first_child();
827 if(eregi("^$", $mta_child->get_content()))
828 {
829 $error->type = "tag_error";
830 $error->data->tag = $nome_figlio;
831 array_push($errors, $error);
832 $cont_err++;
833 }
834 }
835 }
836
837 if($nome_figlio == "resources")
838 {
839 if(strcmp("manifest", $padre->node_name())!=0)
840 {
841 $error->type = "position_error";
842 $error->data->tag = $nome_figlio;
843 $error->data->parent = $padre->node_name();
844 array_push($errors, $error);
845 $cont_err++;
846 }
847 }
848
849 if($nome_figlio == "resource")
850 {
851 if(strcmp("resources", $padre->node_name())!=0)
852 {
853 $error->type = "position_error";
854 $error->data->tag = $nome_figlio;
855 $error->data->parent = $padre->node_name();
856 array_push($errors, $error);
857 $cont_err++;
858 }
859 if(!$figlio->has_attributes())
860 {
861 $error->type = "no_attributes";
862 $error->data->tag = $nome_figlio;
863 array_push($errors, $error);
864 $cont_err++;
865 }
866 $res_attr = $figlio->attributes();
867 $cont_res = count($res_attr);
868 if($cont_res > 6)
869 {
870 $error->type = "too_many_attributes";
871 $error->data->tag = $nome_figlio;
872 array_push($errors, $error);
873 $cont_err++;
874 }
875 for($i=0; $i < $cont_res; $i++)
876 {
877 $ra_n = $res_attr[$i]->node_name();
878 $ra_v = $res_attr[$i]->node_value();
879 if(!$figlio->has_attribute("identifier"))
880 {
881 $error->type = "missing_attribute";
882 $error->data->tag = $nome_figlio;
883 $error->data->attr = "identifier";
884 array_push($errors, $error);
885 $cont_err++;
886 }
887 elseif($ra_n == "identifier")
888 {
889 if(eregi("[[:graph:]]", $ra_v))
890 {
891 array_push($idres_array, $ra_v);
892 } else {
893 $error->type = "attr_error";
894 $error->data->tag = $nome_figlio;
895 $error->data->attr = $ra_n;
896 array_push($errors, $error);
897 }
898 }
899
900 if(!$figlio->has_attribute("type"))
901 {
902 $error->type = "missing_attribute";
903 $error->data->tag = $nome_figlio;
904 $error->tag->attr = "type";
905 array_push($errors, $error);
906 $cont_err++;
907 }
908 elseif($ra_n == "type")
909 {
910 if(strcmp("webcontent", $ra_v)!=0)
911 {
912 $error->type = "attr_error";
913 $error->data->tag = $nome_figlio;
914 $error->data->attr = "type";
915 array_push($errors, $error);
916 $cont_err++;
917 }
918 }
919
920 if(($figlio->has_attribute("href"))&&(strcmp("href", $ra_n)==0))
921 {
922 if(!eregi("[[:graph:]]", $ra_v))
923 {
924 $error->type = "attr_error";
925 $error->data->tag = $nome_figlio;
926 $error->data->attr = "href";
927 array_push($errors, $error);
928 $cont_err++;
929 }
930 }
931
932 // if (xml:base)
933
934 if(($figlio->has_attribute("scormType"))||($figlio->has_attribute("scormtype")))
935 {
936 if((strcmp("scormType", $ra_n)==0)||(strcmp("scormtype", $ra_n)==0))
937 {
938 if(!((strcmp("sco", $ra_v)==0)||(strcmp("asset", $ra_v)==0)))
939 {
940 $error->type = "attr_error";
941 $error->data->tag = $nome_figlio;
942 $error->data->attr = $ra_n;
943 array_push($errors, $error);
944 $cont_err++;
945 }
946 }
947 }
948 else
949 {
950 $error->type = "missing_attribute";
951 $error->data->tag = $nome_figlio;
952 $error->data->attr = "scormType";
953 array_push($errors, $error);
954 $cont_err++;
955
956 }
957
958 if(($figlio->has_attribute("persistState"))&&(strcmp("persistState", $ra_n)==0))
959 {
960 if(!eregi("[0-1]", $ra_v))
961 {
962 $error->type = "attr_error";
963 $error->data->tag = $nome_figlio;
964 $error->data->attr = $ra_n;
965 array_push($errors, $error);
966 $cont_err++;
967 }
968 }
969 }
970
971 }
972
973 if($nome_figlio == "file")
974 {
975 if(!$figlio->has_attributes())
976 {
977 $error->type = "no_attributes";
978 $error->data->tag = $nome_figlio;
979 array_push($errors, $error);
980 $cont_err++;
981 }
982
983 $file_attr = $figlio->attributes();
984 if(($figlio->has_attribute("href"))&&($file_attr[0]->node_name() == "href"))
985 {
986 if(!eregi("[[:print:]]\.[a-z]", $file_attr[0]->node_value()))
987 {
988 $error->type = "attr_error";
989 $error->data->tag = $nome_figlio;
990 $error->data->attr = "href";
991 array_push($errors, $error);
992 $cont_err++;
993 }
994 //else echo "SCANSIONE TAG FILE TERMINATA, OK \n";
995 }
996 else
997 {
998 $error->type = "missing_attribute";
999 $error->data->tag = $nome_figlio;
1000 $error->data->attr = "href";
1001 array_push($errors, $error);
1002 $cont_err++;
1003 }
1004 }
1005
1006 if($nome_figlio == "dependency")
1007 {
1008 if(strcmp("resource", $padre->node_name())!=0)
1009 {
1010 $error->type = "position_error";
1011 $error->data->tag = $nome_figlio;
1012 $error->data->parent = $padre->node_name();
1013 array_push($errors, $error);
1014 $cont_err++;
1015 }
1016 if(!$figlio->has_attributes())
1017 {
1018 $error->type = "no_attributes";
1019 $error->data->tag = $nome_figlio;
1020 array_push($errors, $error);
1021 $cont_err++;
1022 }
1023 $dep_attr = $figlio->attributes();
1024 if(($figlio->has_attribute("identifierref"))&&($dep_attr[0]->node_name() == "identifierref"))
1025 {
1026 // Per valutare il valore di dependency uso l'espressione regolare [[:graph:]]
1027 // che rappresenta tutti i caratteri ASCII stampabili, escluso lo spazio.
1028
1029 if(!eregi("[[:graph:]]", $dep_attr[0]->node_value()))
1030 {
1031 $error->type = "attr_error";
1032 $error->data->tag = $nome_figlio;
1033 $error->data->attr = "identifierref";
1034 array_push($errors, $error);
1035 $cont_err++;
1036 }
1037 //else echo "SCANSIONE TAG DEPENDENCY TERMINATA \n";
1038 } else {
1039 $error->type = "missing_attribute";
1040 $error->data->tag = $nome_figlio;
1041 $error->data->attr = "identifierref";
1042 array_push($errors, $error);
1043 }
1044 }
1045
1046 if(eregi("(CAM[[:blank:]])?[1]\.[3]", $version_value))
1047 {
1048 if($nome_figlio == "sequencing")
1049 {
1050 if(!((strcmp("item", $padre->node_name())==0)||(strcmp("organization", $padre->node_name())==0)))
1051 {
1052 $error->type = "position_error";
1053 $error->data->tag = $nome_figlio;
1054 $error->data->parent = $padre->node_name();
1055 array_push($errors, $error);
1056 $cont_err++;
1057 }
1058
1059 $seq_attr = $figlio->attributes();
1060 $cont_seq = count($seq_attr);
1061 if($cont_seq > 2)
1062 {
1063 $error->type = "too_many_attributes";
1064 $error->data->tag = $nome_figlio;
1065 array_push($errors, $error);
1066 $cont_err++;
1067 }
1068 for($i=0; $i < $cont_seq; $i++)
1069 {
1070 $seq_a = $seq_attr[$i];
1071 if(($figlio->has_attribute("ID"))&&($seq_a->node_name() == "ID"))
1072 {
1073 if(!eregi("[[:graph:]]", $seq_a->node_value()))
1074 {
1075 $error->type = "attr_error";
1076 $error->data->tag = $nome_figlio;
1077 $error->data->attr = "ID";
1078 array_push($errors, $error);
1079 $cont_err++;
1080 }
1081 }
1082
1083 if(($figlio->has_attribute("IDRef"))&&($seq_a->node_name() == "IDRef"))
1084 {
1085 if(!eregi("[[:graph:]]", $seq_a->node_value()))
1086 {
1087 $error->type = "attr_error";
1088 $error->data->tag = $nome_figlio;
1089 $error->data->attr = "IDRef";
1090 array_push($errors, $error);
1091 $cont_err++;
1092 }
1093 }
1094 }
1095 }
1096
1097 if($nome_figlio == "controlMode")
1098 {
1099 if(strcmp("sequencing", $padre->node_name())!=0)
1100 {
1101 $error->type = "position_error";
1102 $error->data->tag = $nome_figlio;
1103 $error->data->parent = $padre->node_name();
1104 array_push($errors, $error);
1105 $cont_err++;
1106 }
1107
1108 $ctrlM_attr = $figlio->attributes();
1109 $cont_ctrlM = count($ctrlM_attr);
1110 if($cont_ctrlM > 6)
1111 {
1112 $error->type = "too_many_attributes";
1113 $error->data->tag = $nome_figlio;
1114 array_push($errors, $error);
1115 $cont_err++;
1116 }
1117
1118 for($i=0; $i < $cont_ctrlM; $i++)
1119 {
1120 $cM_name = $ctrlM_attr[$i]->node_name();
1121 $cM_val = $ctrlM_attr[$i]->node_value();
1122 if(($figlio->has_attribute("choice"))&&($cM_name == "choice"))
1123 {
1124 if(!((strcmp("true", $cM_val)==0)||(strcmp("false", $cM_val)==0)))
1125 {
1126 $error->type = "attr_error";
1127 $error->data->tag = $nome_figlio;
1128 $error->data->attr = $cM_name;
1129 array_push($errors, $error);
1130 $cont_err++;
1131 }
1132 //else "OK CHOICE";
1133 }
1134
1135 if(($figlio->has_attribute("choiceExit"))&&($cM_name == "choiceExit"))
1136 {
1137 if(!((strcmp("true", $cM_val)==0)||(strcmp("false", $cM_val)==0)))
1138 {
1139 $error->type = "attr_error";
1140 $error->data->tag = $nome_figlio;
1141 $error->data->attr = $cM_name;
1142 array_push($errors, $error);
1143 $cont_err++;
1144 }
1145 }
1146
1147 if(($figlio->has_attribute("flow"))&&($cM_name == "flow"))
1148 {
1149 if(!((strcmp("true", $cM_val)==0)||(strcmp("false", $cM_val)==0)))
1150 {
1151 $error->type = "attr_error";
1152 $error->data->tag = $nome_figlio;
1153 $error->data->attr = $cM_name;
1154 array_push($errors, $error);
1155 $cont_err++;
1156 }
1157 }
1158
1159 if(($figlio->has_attribute("forwardOnly"))&&($cM_name == "forwardOnly"))
1160 {
1161 if(!((strcmp("true", $cM_val)==0)||(strcmp("false", $cM_val)==0)))
1162 {
1163 $error->type = "attr_error";
1164 $error->data->tag = $nome_figlio;
1165 $error->data->attr = $cM_name;
1166 array_push($errors, $error);
1167 $cont_err++;
1168 }
1169 }
1170
1171 if(($figlio->has_attribute("01"))&&($cM_name == "01"))
1172 {
1173 if(!((strcmp("true", $cM_val)==0)||(strcmp("false", $cM_val)==0)))
1174 {
1175 $error->type = "attr_error";
1176 $error->data->tag = $nome_figlio;
1177 $error->data->attr = $cM_name;
1178 array_push($errors, $error);
1179 $cont_err++;
1180 }
1181 }
1182
1183 if(($figlio->has_attribute("02"))&&($cM_name == "02"))
1184 {
1185 if(!((strcmp("true", $cM_val)==0)||(strcmp("false", $cM_val)==0)))
1186 {
1187 $error->type = "attr_error";
1188 $error->data->tag = $nome_figlio;
1189 $error->data->attr = $cM_name;
1190 array_push($errors, $error);
1191 $cont_err++;
1192 }
1193 }
1194 }// END FOR
1195
1196 }
1197
1198 if($nome_figlio == "sequencingRules")
1199 {
1200 if(strcmp("sequencing", $padre->node_name())!=0)
1201 {
1202 $error->type = "position_error";
1203 $error->data->tag = $nome_figlio;
1204 $error->data->parent = $padre->node_name();
1205 array_push($errors, $error);
1206 $cont_err++;
1207 }
1208 }
1209
1210 if($nome_figlio == "preConditionRule")
1211 {
1212 if(strcmp("sequencingRules", $padre->node_name())!=0)
1213 {
1214 $error->type = "position_error";
1215 $error->data->tag = $nome_figlio;
1216 $error->data->parent = $padre->node_name();
1217 array_push($errors, $error);
1218 $cont_err++;
1219 }
1220 $preCo_children = $figlio->child_nodes();
1221
1222 }
1223
1224 if($nome_figlio == "postConditionRule")
1225 {
1226 if(strcmp("sequencingRules", $padre->node_name())!=0)
1227 {
1228 $error->type = "position_error";
1229 $error->data->tag = $nome_figlio;
1230 $error->data->parent = $padre->node_name();
1231 array_push($errors, $error);
1232 $cont_err++;
1233 }
1234
1235 }
1236
1237 if($nome_figlio == "exitConditionRule")
1238 {
1239 if(strcmp("sequencingRules", $padre->node_name())!=0)
1240 {
1241 $error->type = "position_error";
1242 $error->data->tag = $nome_figlio;
1243 $error->data->parent = $padre->node_name();
1244 array_push($errors, $error);
1245 $cont_err++;
1246 }
1247
1248 }
1249
1250 if($nome_figlio == "ruleConditions")
1251 {
1252
1253 if(!((strcmp("preConditionRule", $padre->node_name())==0)
1254 ||(strcmp("postConditionRule", $padre->node_name())==0)
1255 ||(strcmp("exitConditionRule", $padre->node_name())==0)))
1256 {
1257 $error->type = "position_error";
1258 $error->data->tag = $nome_figlio;
1259 $error->data->parent = $padre->node_name();
1260 array_push($errors, $error);
1261 $cont_err++;
1262 }
1263
1264 if($figlio->has_attributes())
1265 {
1266 $rCs_attr = $figlio->attributes();
1267 if($rCs_attr[0]->node_name()=="conditionCombination")
1268 {
1269 if(!((strcmp("all", $rCs[0]->node_value())==0)||(strcmp("any", $rCs[0]->node_value())==0)))
1270 {
1271 $error->type = "attr_error";
1272 $error->data->tag = $nome_figlio;
1273 $error->data->attr = "conditionCombination";
1274 array_push($errors, $error);
1275 $cont_err++;
1276 }
1277 }
1278 }
1279 //echo "SCANSIONE TAG RULESCONDITIONS TERMINATA";
1280 }
1281
1282 if($nome_figlio == "ruleCondition")
1283 {
1284 if(strcmp("ruleConditions", $padre->node_name())!=0)
1285 {
1286 $error->type = "position_error";
1287 $error->data->tag = $nome_figlio;
1288 $error->data->parent = $padre->node_name();
1289 array_push($errors, $error);
1290 $cont_err++;
1291 }
1292
1293 if($figlio->has_attributes())
1294 {
1295 $rC_attr = $figlio->attributes();
1296 $cont_rC = count($rC_attr);
1297 if($cont_rC > 4)
1298 {
1299 $error->type = "too_many_attributes";
1300 $error->data->tag = $nome_figlio;
1301 array_push($errors, $error);
1302 $cont_err++;
1303 }
1304 for($i=0; $i < $cont_rC; $i++)
1305 {
1306 $rCa_name = $rC_attr[$i]->node_name();
1307 $rCa_val = $rC_attr[$i]->node_value();
1308 if($rCa_name == "referencedObjective")
1309 {
1310 if(!eregi("[[:graph:]]", $rCa_val))
1311 {
1312 $error->type = "attr_error";
1313 $error->data->tag = $nome_figlio;
1314 $error->data->attr = $rCa_name;
1315 array_push($errors, $error);
1316 $cont_err++;
1317 }
1318 }
1319
1320 if($rCa_name == "measureThreshold")
1321 {
1322 settype($rCa_val, "float");
1323 if(($rCa_val < -1.0000)||($rCa_val > 1.0000))
1324 {
1325 $error->type = "attr_error";
1326 $error->data->tag = $nome_figlio;
1327 $error->data->attr = $rCa_name;
1328 array_push($errors, $error);
1329 $cont_err++;
1330 }
1331 }
1332
1333 if($rCa_name == "operator")
1334 {
1335 if((!eregi("not", $rCa_val))||(!eregi("noOp", $rCa_val)))
1336 {
1337 $error->type = "attr_error";
1338 $error->data->tag = $nome_figlio;
1339 $error->data->attr = $rCa_name;
1340 array_push($errors, $error);
1341 $cont_err++;
1342 }
1343 }
1344
1345 if($rCa_name == "condition")
1346 {
1347 if(!is_cond_val($rCa_val))
1348 {
1349 $error->type = "attr_error";
1350 $error->data->tag = $nome_figlio;
1351 $error->data->attr = $rCa_name;
1352 array_push($errors, $error);
1353 $cont_err++;
1354 }
1355 }
1356 }// END FOR
1357 }
1358 }
1359
1360 if($nome_figlio == "ruleAction")
1361 {
1362 if($padre->node_name() == "preConditionRule")
1363 {
1364 if(($figlio->has_attributes())&&($figlio->has_attribute("action")))
1365 {
1366 $rAc_attr1 = $figlio->attributes();
1367 if($rAc_attr1[0]->node_name() != "action")
1368 {
1369 $error->type = "missing_attribute";
1370 $error->data->tag = $nome_figlio;
1371 $error->data->attr = "action";
1372 array_push($errors, $error);
1373 $cont_err++;
1374 }
1375 elseif(!is_action1($rAc_attr1[0]->node_value()))
1376 {
1377 $error->type = "attr_error";
1378 $error->data->tag = $nome_figlio;
1379 $error->data->attr = "action";
1380 array_push($errors, $error);
1381 $cont_err++;
1382 }
1383
1384 }
1385 else
1386 {
1387 $error->type = "missing_attribute";
1388 $error->data->tag = $nome_figlio;
1389 $error->data->attr = "action";
1390 array_push($errors, $error);
1391 $cont_err++;
1392 }
1393 }
1394
1395 elseif($padre->node_name() == "postConditionRule")
1396 {
1397 if(($figlio->has_attributes())&&($figlio->has_attribute("action")))
1398 {
1399 $rAc_attr2 = $figlio->attributes();
1400 if($rAc_attr2[0]->node_name() != "action")
1401 {
1402 $error->type = "missing_attribute";
1403 $error->data->tag = $nome_figlio;
1404 $error->data->attr = "action";
1405 array_push($errors, $error);
1406 $cont_err++;
1407 }
1408 elseif(!is_action2($rAc_attr2[0]->node_value()))
1409 {
1410 $error->type = "attr_error";
1411 $error->data->tag = $nome_figlio;
1412 $error->data->attr = "action";
1413 array_push($errors, $error);
1414 $cont_err++;
1415 }
1416
1417 }
1418 else
1419 {
1420 $error->type = "missing_attribute";
1421 $error->data->tag = $nome_figlio;
1422 $error->data->attr = "action";
1423 array_push($errors, $error);
1424 $cont_err++;
1425 }
1426 }
1427
1428 elseif($padre->node_name() == "exitConditionRule")
1429 {
1430 if(($figlio->has_attributes())&&($figlio->has_attribute("action")))
1431 {
1432 $rAc_attr3 = $figlio->attributes();
1433 if($rAc_attr3[0]->node_name() != "action")
1434 {
1435 $error->type = "missing_attribute";
1436 $error->data->tag = $nome_figlio;
1437 $error->data->attr = "action";
1438 array_push($errors, $error);
1439 $cont_err++;
1440 }
1441 elseif($rAc_attr3[0]->node_value() != "exit")
1442 {
1443 $error->type = "attr_error";
1444 $error->data->tag = $nome_figlio;
1445 $error->data->attr = "action";
1446 array_push($errors, $error);
1447 $cont_err++;
1448 }
1449
1450 }
1451 else
1452 {
1453 $error->type = "missing_attribute";
1454 $error->data->tag = $nome_figlio;
1455 $error->data->attr = "action";
1456 array_push($errors, $error);
1457 $cont_err++;
1458 }
1459 }
1460 else
1461 {
1462 $error->type = "position_error";
1463 $error->data->tag = $nome_figlio;
1464 $error->data->parent = $padre->node_name();
1465 array_push($errors, $error);
1466 $cont_err++;
1467 }
1468 }
1469
1470 if($nome_figlio == "limitConditions")
1471 {
1472 if(strcmp("sequencing", $padre->node_name())!=0)
1473 {
1474 $error->type = "position_error";
1475 $error->data->tag = $nome_figlio;
1476 $error->data->parent = $padre->node_name();
1477 array_push($errors, $error);
1478 $cont_err++;
1479 }
1480 if($figlio->has_attributes())
1481 {
1482 $lAc_attr = $figlio->attributes();
1483 $cont_lAc = count($lAc_attr);
1484 if($cont_lAc > 2)
1485 {
1486 $error->type = "too_many_attributes";
1487 $error->data->tag = $nome_figlio;
1488 array_push($errors, $error);
1489 $cont_err++;
1490 }
1491 for($i=0; $i < $cont_lAc; $i++)
1492 {
1493 $lAc_name = $lAc_attr[$i]->node_name();
1494 $lAc_val = $lAc_attr[$i]->node_value();
1495 if(($figlio->has_attribute("attemptLimit"))&&($lAc_name == "attemptLimit"))
1496 {
1497 settype($lAc_val, "int");
1498 if($lAc_val < 0)
1499 {
1500 $error->type = "attr_error";
1501 $error->data->tag = $nome_figlio;
1502 $error->data->attr = $lAc_name;
1503 array_push($errors, $error);
1504 $cont_err++;
1505 }
1506 }
1507 if($lAc_name == "attemptAbsoluteDurationLimit")
1508 {
1509 if(!eregi("[P][[:digit:]][Y][0-9][M][0-9][D][0-9][H][0-60][M][0-60][S]", $lAc_val))
1510 {
1511 $error->type = "attr_error";
1512 $error->data->tag = $nome_figlio;
1513 $error->data->attr = $lAc_val;
1514 array_push($errors, $error);
1515 $cont_err++;
1516 }
1517 }
1518 }
1519 }
1520 }
1521
1522 if($nome_figlio == "auxiliaryResources")
1523 {
1524 if(strcmp("sequencing", $padre->node_name())!=0)
1525 {
1526 $error->type = "position_error";
1527 $error->data->tag = $nome_figlio;
1528 $error->data->parent = $padre->node_name();
1529 array_push($errors, $error);
1530 $cont_err++;
1531 }
1532
1533 }
1534
1535 if($nome_figlio == "auxiliaryResource")
1536 {
1537 if(strcmp("auxiliaryResources", $padre->node_name())!=0)
1538 {
1539 $error->type = "position_error";
1540 $error->data->tag = $nome_figlio;
1541 $error->data->parent = $padre->node_name();
1542 array_push($errors, $error);
1543 $cont_err++;
1544 }
1545 if($figlio->has_attributes())
1546 {
1547 $aux_attr = $figlio->attributes();
1548 $cont_aux = count($aux_attr);
1549 if($cont_aux != 2)
1550 {
1551 $error->type = "too_many_attributes";
1552 $error->data->tag = $nome_figlio;
1553 array_push($errors, $error);
1554 $cont_err++;
1555 }
1556 for($i=0; $i < $cont_aux; $i++)
1557 {
1558 $aux_n = $aux_attr[$i]->node_name();
1559 $aux_v = $aux_attr[$i]->node_value();
1560 if((strcmp("auxiliaryResourceID", $aux_n)!=0)&&(strcmp("purpose", $aux_n)!=0))
1561 {
1562 $error->type = "missing_attribute";
1563 $error->data->tag = $nome_figlio;
1564 $error->data->attr = $aux_n;
1565 array_push($errors, $error);
1566 $cont_err++;
1567 }
1568 elseif($aux_n == "auxiliaryResourceID")
1569 {
1570 if(!eregi("[[:graph:]]", $aux_v))
1571 {
1572 $error->type = "attr_error";
1573 $error->data->tag = $nome_figlio;
1574 $error->data->attr = $aux_n;
1575 array_push($errors, $error);
1576 $cont_err++;
1577 }
1578 }
1579 elseif($aux_n == "purpose")
1580 {
1581 if(!eregi("[[:graph:]]", $aux_v))
1582 {
1583 $error->type = "attr_error";
1584 $error->data->tag = $nome_figlio;
1585 $error->data->attr = $aux_n;
1586 array_push($errors, $error);
1587 $cont_err++;
1588 }
1589 }
1590 }
1591 }//echo "SCANSIONE TAG AUXILIARYRESOURCE TERMINATA";
1592 }
1593
1594 if($nome_figlio == "rollupRules")
1595 {
1596 if(strcmp("sequencing", $padre->node_name())!=0)
1597 {
1598 $error->type = "position_error";
1599 $error->data->tag = $nome_figlio;
1600 $error->data->parent = $padre->node_name();
1601 array_push($errors, $error);
1602 $cont_err++;
1603 }
1604 if($figlio->has_attributes())
1605 {
1606 $rules_attr = $figlio->attributes();
1607 $cont_rules = count($rules_attr);
1608 if($cont_rules > 3)
1609 {
1610 $error->type = "too_many_attributes";
1611 $error->data->tag = $nome_figlio;
1612 array_push($errors, $error);
1613 $cont_err++;
1614 }
1615 for($i=0; $i < $cont_rules; $i++)
1616 {
1617 $rules_nome = $rules_attr[$i]->node_name();
1618 $rules_val = $rules_attr[$i]->node_value();
1619 if($rules_nome == "rollupObjectiveSatisfied")
1620 {
1621 if(!((strcmp("true", $rules_val)==0)||(strcmp("false", $rules_val)==0)))
1622 {
1623 $error->type = "attr_error";
1624 $error->data->tag = $nome_figlio;
1625 $error->data->attr = $rules_nome;
1626 array_push($errors, $error);
1627 //echo "ERROR, rollupObjectiveSatisfied puo'assumere solo valori booleani";
1628 $cont_err++;
1629 }
1630 }
1631 if($rules_nome == "rollupProgressCompletion")
1632 {
1633 if(!((strcmp("true", $rules_val)==0)||(strcmp("false", $rules_val)==0)))
1634 {
1635 $error->type = "attr_error";
1636 $error->data->tag = $nome_figlio;
1637 $error->data->attr = $rules_nome;
1638 array_push($errors, $error);
1639 $cont_err++;
1640 }
1641 }
1642 if($rules_nome == "objectiveMeasureWeight")
1643 {
1644 settype($rules_val, "float");
1645 if(($rules_val < 0.0000)||($rules_val > 1.0000))
1646 {
1647 $error->type = "attr_error";
1648 $error->data->tag = $nome_figlio;
1649 $error->data->attr = $rules_nome;
1650 array_push($errors, $error);
1651 $cont_err++;
1652 }
1653 }
1654 }//END FOR
1655 }//echo "SCANSIONE TAG ROLLUPRULES TERMINATA";
1656 }// END ROLLUPRULES
1657
1658 if($nome_figlio == "rollupRule")
1659 {
1660 if(strcmp("rollupRules", $padre->node_name())!= 0)
1661 {
1662 $error->type = "position_error";
1663 $error->data->tag = $nome_figlio;
1664 $error->data->parent = $padre->node_name();
1665 array_push($errors, $error);
1666 $cont_err++;
1667 }
1668 if($figlio->has_attributes())
1669 {
1670 $rule_attr = $figlio->attributes();
1671 $cont_rule = count($rule_attr);
1672 if($cont_rule > 3)
1673 {
1674 $error->type = "too_many_attributes";
1675 $error->data->tag = $nome_figlio;
1676 array_push($errors, $error);
1677 $cont_err++;
1678 }
1679 for($i=0; $i < $cont_rule; $i++)
1680 {
1681 $rule_name = $rule_attr[$i]->node_name();
1682 $rule_val = $rule_attr[$i]->node_value();
1683 if($rule_name == "childActivitySet")
1684 {
1685 if(!((strcmp("all", $rule_val)==0)||(strcmp("any", $rule_val)==0)))
1686 {
1687 $error->type = "attr_error";
1688 $error->data->tag = $nome_figlio;
1689 $error->data->attr = $rule_nome;
1690 array_push($errors, $error);
1691 $cont_err++;
1692 }
1693 }
1694 if($rule_name == "minimumCount")
1695 {
1696 settype($rule_val, "int");
1697 if($rule_val < 0)
1698 {
1699 $error->type = "attr_error";
1700 $error->data->tag = $nome_figlio;
1701 $error->data->attr = $rule_nome;
1702 array_push($errors, $error);
1703 $cont_err++;
1704 }
1705 }
1706 if($rule_name == "minimumPercent")
1707 {
1708 settype($rule_val, "float");
1709 if(($rule_val < 0.0000)||($rule_val > 1.0000))
1710 {
1711 $error->type = "attr_error";
1712 $error->data->tag = $nome_figlio;
1713 $error->data->attr = $rules_nome;
1714 array_push($errors, $error);
1715 $cont_err++;
1716 }
1717 }
1718 }
1719 }//echo "SCANSIONE TAG ROLLUPRULE TERMINATA";
1720 }
1721
1722 if($nome_figlio == "rollupConditions")
1723 {
1724 if(strcmp("rollupRule", $padre->node_name())!=0)
1725 {
1726 $error->type = "position_error";
1727 $error->data->tag = $nome_figlio;
1728 $error->data->parent = $padre->node_name();
1729 array_push($errors, $error);
1730 $cont_err++;
1731 }
1732 if(($figlio->has_attributes())&&($figlio->has_attribute("conditionCombination")))
1733 {
1734 $rCo_attr = $figlio->attributes();
1735 $rCo_name = $rCo_attr[0]->node_name();
1736 $rCo_val = $rCo_attr[0]->node_val();
1737 if($rCo_name != "conditionCombination")
1738 {
1739 $error->type = "missing_attribute";
1740 $error->data->tag = $nome_figlio;
1741 $error->data->attr = $rCo_name;
1742 array_push($errors, $error);
1743 $cont_err++;
1744 }
1745 elseif(!((strcmp("all", $rCo_val)==0)||(strcmp("any", $rCo_val)==0)))
1746 {
1747 $error->type = "attr_error";
1748 $error->data->tag = $nome_figlio;
1749 $error->data->attr = $rCo_name;
1750 array_push($errors, $error);
1751 $cont_err++;
1752 }
1753 }
1754 //echo "SCANSIONE TAG ROLLUPCONDITIONS TERMINATA";
1755 }
1756
1757 if($nome_figlio == "rollupCondition")
1758 {
1759 if(strcmp("rollupConditions", $padre->node_name())!=0)
1760 {
1761 $error->type = "position_error";
1762 $error->data->tag = $nome_figlio;
1763 $error->data->parent = $padre->node_name();
1764 array_push($errors, $error);
1765 $cont_err++;
1766 }
1767 if($figlio->has_attributes())
1768 {
1769 $rCond_attr = $figlio->attributes();
1770 $cont_rCond = count($rCond_attr);
1771 if($cont_rCond > 2)
1772 {
1773 $error->type = "too_many_attributes";
1774 $error->data->tag = $nome_figlio;
1775 array_push($errors, $error);
1776 $cont_err++;
1777 }
1778 for($i=0; $i < $cont_rCond; $i++)
1779 {
1780 $rCond_n = $rCond_attr[$i]->node_name();
1781 $rCond_v = $rCond_attr[$i]->node_value();
1782 if($rCond_n == "operator")
1783 {
1784 if(!((strcmp("not", $rCond_v)==0)||(strcmp("noOp", $rCond_v)==0)))
1785 {
1786 $error->type = "attr_error";
1787 $error->data->tag = $nome_figlio;
1788 $error->data->attr = $rCond_n;
1789 array_push($errors, $error);
1790 $cont_err++;
1791 }
1792 }
1793 elseif($rCond_n == "condition")
1794 {
1795 if(!is_rcond_val($rCond_v))
1796 {
1797 $error->type = "attr_error";
1798 $error->data->tag = $nome_figlio;
1799 $error->data->attr = $rCond_n;
1800 array_push($errors, $error);
1801 $cont_err++;
1802 }
1803 }
1804 else
1805 {
1806 $error->type = "missing_attribute";
1807 $error->data->tag = $nome_figlio;
1808 $error->data->attr = "condition";
1809 array_push($errors, $error);
1810 $cont_err++;
1811 }
1812 }
1813 }
1814 else
1815 {
1816 $error->type = "no_attributes";
1817 $error->data->tag = $nome_figlio;
1818 array_push($errors, $error);
1819 $cont_err++;
1820 }
1821 }
1822
1823 if($nome_figlio == "rollupAction")
1824 {
1825 if(strcmp("rollupRule", $padre->node_name())!=0)
1826 {
1827 $error->type = "position_error";
1828 $error->data->tag = $nome_figlio;
1829 $error->data->parent = $padre->node_name();
1830 array_push($errors, $error);
1831 $cont_err++;
1832 }
1833 if(($figlio->has_attributes())&&($figlio->has_attribute("action")))
1834 {
1835 $roAc_attr = $figlio->attributes();
1836 if($roAc_attr[0]->node_name() != "action")
1837 {
1838 $error->type = "missing_attribute";
1839 $error->data->tag = $nome_figlio;
1840 $error->data->attr = "action";
1841 array_push($errors, $error);
1842 $cont_err++;
1843 }
1844 elseif(!is_rolAc_val($roAc_attr[0]->node_value()))
1845 {
1846 $error->type = "attr_error";
1847 $error->data->tag = $nome_figlio;
1848 $error->data->attr = "action";
1849 array_push($errors, $error);
1850 $cont_err++;
1851 }
1852 }
1853 else
1854 {
1855 $error->type = "missing_attribute";
1856 $error->data->tag = $nome_figlio;
1857 $error->data->attr = "action";
1858 array_push($errors, $error);
1859 $cont_err++;
1860 }
1861 }
1862
1863 if($nome_figlio == "objectives")
1864 {
1865 if(strcmp("sequencing", $padre->node_name())!=0)
1866 {
1867 $error->type = "position_error";
1868 $error->data->tag = $nome_figlio;
1869 $error->data->parent = $padre->node_name();
1870 array_push($errors, $error);
1871 $cont_err++;
1872 }
1873 }
1874
1875 if($nome_figlio == "primaryObjective")
1876 {
1877 if(strcmp("objectives", $padre->node_name())!=0)
1878 {
1879 $error->type = "position_error";
1880 $error->data->tag = $nome_figlio;
1881 $error->data->parent = $padre->node_name();
1882 array_push($errors, $error);
1883 $cont_err++;
1884 }
1885 if($figlio->has_attributes())
1886 {
1887 $prObj_attr = $figlio->attributes();
1888 $cont_prObj = count($prObj_attr);
1889 if($cont_prObj > 2)
1890 {
1891 $error->type = "too_many_attributes";
1892 $error->data->tag = $nome_figlio;
1893 array_push($errors, $error);
1894 $cont_err++;
1895 }
1896 for($i=0; $i < $cont_prObj; $i++)
1897 {
1898 $pro_n = $prObj_attr[$i]->node_name();
1899 $pro_v = $prObj_attr[$i]->node_value();
1900 if($pro_n == "satisfiedByMeasure")
1901 {
1902 if(!((strcmp("true", $pro_v)==0)||(strcmp("false", $pro_v)==0)))
1903 {
1904 $error->type = "attr_error";
1905 $error->data->tag = $nome_figlio;
1906 $error->data->attr = $pro_n;
1907 array_push($errors, $error);
1908 $cont_err++;
1909 }
1910 }
1911 if($pro_n == "objectiveID")
1912 {
1913 if(!eregi("[[:graph:]]", $pro_v))
1914 {
1915 $error->type = "attr_error";
1916 $error->data->tag = $nome_figlio;
1917 $error->data->attr = $pro_n;
1918 array_push($errors, $error);
1919 $cont_err++;
1920 }
1921 }
1922 }
1923 }
1924 }
1925
1926 if($nome_figlio == "minNormalizedMeasure")
1927 {
1928 $fn = $padre->node_name();
1929 if(!((strcmp("primaryObjective", $fn)==0)||(strcmp("objective", $fn)==0)))
1930 {
1931 $error->type = "position_error";
1932 $error->data->tag = $nome_figlio;
1933 $error->data->parent = $padre->node_name();
1934 array_push($errors, $error);
1935 $cont_err++;
1936 }
1937
1938 if($figlio->has_child_nodes())
1939 {
1940 $figlio1 = $figlio->first_child();
1941 if($figlio1->node_type() != 3)
1942 {
1943 $error->type = "not_corr_type";
1944 $error->data->tag = $nome_figlio;
1945 array_push($errors, $error);
1946 $cont_err++;
1947 }
1948 settype($figlio1->get_content(), "float");
1949 if(($figlio1->get_content() < 0.0)||($figlio1->get_content() > 1.0))
1950 {
1951 $error->type = "tag_error";
1952 $error->data->tag = $nome_figlio;
1953 $error->data->value = $figlio1->get_content();
1954 array_push($errors, $error);
1955 $cont_err++;
1956 }
1957 }
1958 else
1959 {
1960 $error->type = "tag_error";
1961 $error->data->tag = $nome_figlio;
1962 array_push($errors, $error);
1963 $cont_err++;
1964 }
1965 }
1966
1967 if($nome_figlio == "mapInfo")
1968 {
1969 $pn = $padre->node_name();
1970 if(!((strcmp("primaryObjective", $pn)==0)||(strcmp("objective", $pn)==0)))
1971 {
1972 $error->type = "position_error";
1973 $error->data->tag = $nome_figlio;
1974 $error->data->parent = $padre->node_name();
1975 array_push($errors, $error);
1976 $cont_err++;
1977 }
1978 if($figlio->has_attributes())
1979 {
1980 $map_attr = $figlio->attributes();
1981 $cont_map = count($map_attr);
1982 if($cont_map > 5)
1983 {
1984 $error->type = "too_many_attributes";
1985 $error->data->tag = $nome_figlio;
1986 array_push($errors, $error);
1987 $cont_err++;
1988 }
1989 if(!$figlio->has_attribute("targetObjectiveID"))
1990 {
1991 $error->type = "missing_attribute";
1992 $error->data->tag = $nome_figlio;
1993 $error->data->attr = "targetObjectiveID";
1994 array_push($errors, $error);
1995 $cont_err++;
1996 }
1997 for($i=0; $i < $cont_map; $i++)
1998 {
1999 $map_n = $map_attr[$i]->node_name();
2000 $map_v = $map_attr[$i]->node_value();
2001 if($map_n == "targetObjectiveID")
2002 {
2003 if(!eregi("[[:graph:]]", $map_v))
2004 {
2005 $error->type = "attr_error";
2006 $error->data->tag = $nome_figlio;
2007 $error->data->attr = "targetObjectiveID";
2008 array_push($errors, $error);
2009 $cont_err++;
2010 }
2011 }
2012 if($map_n == "readSatisfiedStatus")
2013 {
2014 if(!((strcmp("true", $map_v)==0)||(strcmp("false", $map_v)==0)))
2015 {
2016 $error->type = "attr_error";
2017 $error->data->tag = $nome_figlio;
2018 $error->data->attr = $map_n;
2019 array_push($errors, $error);
2020 $cont_err++;
2021 }
2022 }
2023 if($map_n == "readNormalizedMeasure")
2024 {
2025 if(!((strcmp("true", $map_v)==0)||(strcmp("false", $map_v)==0)))
2026 {
2027 $error->type = "attr_error";
2028 $error->data->tag = $nome_figlio;
2029 $error->data->attr = $map_n;
2030 array_push($errors, $error);
2031 $cont_err++;
2032 }
2033 }
2034 if($map_n == "writeSatisfiedStatus")
2035 {
2036 if(!((strcmp("true", $map_v)==0)||(strcmp("false", $map_v)==0)))
2037 {
2038 $error->type = "attr_error";
2039 $error->data->tag = $nome_figlio;
2040 $error->data->attr = $map_n;
2041 array_push($errors, $error);
2042 $cont_err++;
2043 }
2044 }
2045 if($map_n == "writeNormalizedMeasure")
2046 {
2047 if(!((strcmp("true", $map_v)==0)||(strcmp("false", $map_v)==0)))
2048 {
2049 $error->type = "attr_error";
2050 $error->data->tag = $nome_figlio;
2051 $error->data->attr = $map_n;
2052 array_push($errors, $error);
2053 $cont_err++;
2054 }
2055 }
2056 }// END FOR
2057 }
2058 else
2059 {
2060 $error->type = "missing_attribute";
2061 $error->data->tag = $nome_figlio;
2062 $error->data->attr = "targetObjectiveID";
2063 array_push($errors, $error);
2064 $cont_err++;
2065 }
2066
2067 }
2068
2069 if($nome_figlio == "objective")
2070 {
2071 if(strcmp("objectives", $padre->node_name())!=0)
2072 {
2073 $error->type = "position_error";
2074 $error->data->tag = $nome_figlio;
2075 $error->data->parent = $padre->node_name();
2076 array_push($errors, $error);
2077 $cont_err++;
2078 }
2079 if($figlio->has_attributes())
2080 {
2081 $obj_attr = $figlio->attributes();
2082 $cont_obj = count($obj_attr);
2083 if($cont_obj > 2)
2084 {
2085 $error->type = "too_many_attributes";
2086 $error->data->tag = $nome_figlio;
2087 array_push($errors, $error);
2088 $cont_err++;
2089 }
2090 for($i=0; $i < $cont_obj; $i++)
2091 {
2092 $ob_n = $obj_attr[$i]->node_name();
2093 $ob_v = $obj_attr[$i]->node_value();
2094 if($ob_n == "satisfiedByMeasure")
2095 {
2096 if(!((strcmp("true", $ob_v)==0)||(strcmp("false", $ob_v)==0)))
2097 {
2098 $error->type = "attr_error";
2099 $error->data->tag = $nome_figlio;
2100 $error->data->attr = $ob_n;
2101 array_push($errors, $error);
2102 $cont_err++;
2103 }
2104 }
2105 if($ob_n == "objectiveID")
2106 {
2107 if(!eregi("[[:graph:]]", $ob_v))
2108 {
2109 $error->type = "attr_error";
2110 $error->data->tag = $nome_figlio;
2111 $error->data->attr = $ob_n;
2112 array_push($errors, $error);
2113 $cont_err++;
2114 }
2115 }
2116 }
2117 }
2118 }
2119
2120 if($nome_figlio == "randomizationControls")
2121 {
2122 if(strcmp("sequencing", $padre->node_name())!=0)
2123 {
2124 $error->type = "position_error";
2125 $error->data->tag = $nome_figlio;
2126 $error->data->parent = $padre->node_name();
2127 array_push($errors, $error);
2128 $cont_err++;
2129 }
2130 if($figlio->has_attributes())
2131 {
2132 $rand_attr = $figlio->attributes();
2133 $cont_rand = count($rand_attr);
2134 if($cont_rand > 4)
2135 {
2136 $error->type = "too_many_attributes";
2137 $error->data->tag = $nome_figlio;
2138 array_push($errors, $error);
2139 $cont_err++;
2140 }
2141 for($i=0; $i < $cont_rand; $i++)
2142 {
2143 $rAt_n = $rand_attr[$i]->node_name();
2144 $rAt_v = $rand_attr[$i]->node_value();
2145 if($rAt_n == "randomizationTiming")
2146 {
2147 if(!is_randT_attr($rAt_v))
2148 {
2149 $error->type = "attr_error";
2150 $error->data->tag = $nome_figlio;
2151 $error->data->attr = $rAt_n;
2152 array_push($errors, $error);
2153 $cont_err++;
2154 }
2155 }
2156 if($rAt_n == "selectCount")
2157 {
2158 setttype($rAt_v, "int");
2159 if($rAt_v < 0)
2160 {
2161 $error->type = "attr_error";
2162 $error->data->tag = $nome_figlio;
2163 $error->data->attr = $rAt_n;
2164 array_push($errors, $error);
2165 $cont_err++;
2166 }
2167 }
2168 if($rAt_n == "reorderChildren")
2169 {
2170 if(!((strcmp("true", $rAt_v)==0)||(strcmp("false", $rAt_v)==0)))
2171 {
2172 $error->type = "attr_error";
2173 $error->data->tag = $nome_figlio;
2174 $error->data->attr = $rAt_n;
2175 array_push($errors, $error);
2176 $cont_err++;
2177 }
2178 }
2179 if($rAt_v == "selectionTiming")
2180 {
2181 if(!is_randT_attr($rAt_v))
2182 {
2183 $error->type = "attr_error";
2184 $error->data->tag = $nome_figlio;
2185 $error->data->attr = $rAt_n;
2186 array_push($errors, $error);
2187 $cont_err++;
2188 }
2189 }
2190 }
2191 }//echo "SCANSIONE TAG RANDOMIZATION CONTROLS TERMINATA";
2192 }
2193
2194 if($nome_figlio == "deliveryControls")
2195 {
2196 if(strcmp("sequencing", $padre->node-name())!=0)
2197 {
2198 $error->type = "position_error";
2199 $error->data->tag = $nome_figlio;
2200 $error->data->parent = $padre->node_name();
2201 array_push($errors, $error);
2202 $cont_err++;
2203 }
2204 if($figlio->has_attributes())
2205 {
2206 $delv_attr = $figlio->attributes();
2207 $cont_delv = count($delv_attr);
2208 if($cont_delv > 3)
2209 {
2210 $error->type = "too_many_attributes";
2211 $error->data->tag = $nome_figlio;
2212 array_push($errors, $error);
2213 $cont_err++;
2214 }
2215 for($i=0; $i < $cont_delv; $i++)
2216 {
2217 $delv_n = $delv_attr[$i]->node_name();
2218 $delv_v + $delv_attr[$i]->node_value();
2219 if($delv_n == "tracked")
2220 {
2221 if(!((strcmp("true", $delv_v)==0)||(strcmp("false", $delv_v)==0)))
2222 {
2223 $error->type = "attr_error";
2224 $error->data->tag = $nome_figlio;
2225 $error->data->attr = $delv_n;
2226 array_push($errors, $error);
2227 $cont_err++;
2228 }
2229 }
2230 if($delv_n == "completionSetByContent")
2231 {
2232 if(!((strcmp("true", $delv_v)==0)||(strcmp("false", $delv_v)==0)))
2233 {
2234 $error->type = "attr_error";
2235 $error->data->tag = $nome_figlio;
2236 $error->data->attr = $delv_n;
2237 array_push($errors, $error);
2238 $cont_err++;
2239 }
2240 }
2241 if($delv_n == "objectiveSetByContent")
2242 {
2243 if(!((strcmp("true", $delv_v)==0)||(strcmp("false", $delv_v)==0)))
2244 {
2245 $error->type = "attr_error";
2246 $error->data->tag = $nome_figlio;
2247 $error->data->attr = $delv_n;
2248 array_push($errors, $error);
2249 $cont_err++;
2250 }
2251 }
2252 }
2253 }//echo "SCANSIONE TAG DELIVERYCONTROLS COMPLETATA";
2254 }
2255
2256 if($nome_figlio == "constrainedChoiceConsiderations")
2257 {
2258 if(strcmp("sequencing", $padre->node_name())!=0)
2259 {
2260 $error->type = "position_error";
2261 $error->data->tag = $nome_figlio;
2262 $error->data->parent = $padre->node_name();
2263 array_push($errors, $error);
2264 $cont_err++;
2265 }
2266 if($figlio->has_attributes())
2267 {
2268 $ccc_attr = $figlio->attributes();
2269 $cont_ccc = count($ccc_attr);
2270 if($cont_ccc > 2)
2271 {
2272 $error->type = "too_many_attributes";
2273 $error->data->tag = $nome_figlio;
2274 array_push($errors, $error);
2275 $cont_err++;
2276 }
2277 for($i=0; $i < $cont_ccc; $i++)
2278 {
2279 $ccc_n = $ccc_attr[$i]->node_name();
2280 $ccc_v + $ccc_attr[$i]->node_value();
2281 if($ccc_n == "preventActivation")
2282 {
2283 if(!((strcmp("true", $ccc_v)==0)||(strcmp("false", $ccc_v)==0)))
2284 {
2285 $error->type = "attr_error";
2286 $error->data->tag = $nome_figlio;
2287 $error->data->attr = $ccc_n;
2288 array_push($errors, $error);
2289 $cont_err++;
2290 }
2291 }
2292 if($ccc_n == "constrainChoice")
2293 {
2294 if(!((strcmp("true", $ccc_v)==0)||(strcmp("false", $ccc_v)==0)))
2295 {
2296 $error->type = "attr_error";
2297 $error->data->tag = $nome_figlio;
2298 $error->data->attr = $ccc_n;
2299 array_push($errors, $error);
2300 $cont_err++;
2301 }
2302 }
2303 }
2304 }
2305 }
2306
2307 if($nome_figlio == "rollupConsiderations")
2308 {
2309 if(strcmp("sequencing", $padre->node_name())!=0)
2310 {
2311 $error->type = "position_error";
2312 $error->data->tag = $nome_figlio;
2313 $error->data->parent = $padre->node_name();
2314 array_push($errors, $error);
2315 $cont_err++;
2316 }
2317 if($figlio->has_attributes())
2318 {
2319 $rolCo_attr = $figlio->attributes();
2320 $cont_rolCo = count($rolCo_attr);
2321 if($cont_rolCo > 5)
2322 {
2323 $error->type = "too_many_attributes";
2324 $error->data->tag = $nome_figlio;
2325 array_push($errors, $error);
2326 $cont_err++;
2327 }
2328 for($i=0; $i < $cont_rolCo; $i++)
2329 {
2330 $rolCo_n = $rolCo_attr[$i]->node_name();
2331 $rolCo_v = $rolCo_attr[$i]->node_value();
2332 if($rolCo_n == "measureSatisfactionIfActive")
2333 {
2334 if(!((strcmp("true", $rolCo_v)==0)||(strcmp("false", $rolCo_v)==0)))
2335 {
2336 $error->type = "attr_error";
2337 $error->data->tag = $nome_figlio;
2338 $error->data->attr = $rolCo_n;
2339 array_push($errors, $error);
2340 $cont_err++;
2341 }
2342 }
2343 if($rolCo_n == "requiredForSatisfied")
2344 {
2345 if(!is_rolCo_val($rolCo_v))
2346 {
2347 $error->type = "attr_error";
2348 $error->data->tag = $nome_figlio;
2349 $error->data->attr = $rolCo_n;
2350 array_push($errors, $error);
2351 $cont_err++;
2352 }
2353 }
2354 if($rolCo_n == "requiredForNotSatisfied")
2355 {
2356 if(!is_rolCo_val($rolCo_v))
2357 {
2358 $error->type = "attr_error";
2359 $error->data->tag = $nome_figlio;
2360 $error->data->attr = $rolCo_n;
2361 array_push($errors, $error);
2362 $cont_err++;
2363 }
2364 }
2365 if($rolCo_n == "requiredForCompleted")
2366 {
2367 if(!is_rolCo_val($rolCo_v))
2368 {
2369 $error->type = "attr_error";
2370 $error->data->tag = $nome_figlio;
2371 $error->data->attr = $rolCo_n;
2372 array_push($errors, $error);
2373 $cont_err++;
2374 }
2375 }
2376 if($rolCo_n == "requiredForIncomplete")
2377 {
2378 if(!is_rolCo_val($rolCo_v))
2379 {
2380 $error->type = "attr_error";
2381 $error->data->tag = $nome_figlio;
2382 $error->data->attr = $rolCo_n;
2383 array_push($errors, $error);
2384 $cont_err++;
2385 }
2386 }
2387 }
2388 }
2389 }
2390
2391 if($nome_figlio == "presentation")
2392 {
2393 if(strcmp("item", $padre->node_name())!=0)
2394 {
2395 $error->type = "position_error";
2396 $error->data->tag = $nome_figlio;
2397 $error->data->parent = $padre->node_name();
2398 array_push($errors, $error);
2399 $cont_err++;
2400 }
2401 }
2402
2403 if($nome_figlio == "navigationInterface")
2404 {
2405 if(strcmp("presentation", $padre->node_name())!=0)
2406 {
2407 $error->type = "position_error";
2408 $error->data->tag = $nome_figlio;
2409 $error->data->parent = $padre->node_name();
2410 array_push($errors, $error);
2411 $cont_err++;
2412 }
2413 }
2414
2415 if($nome_figlio == "hideLMSUI")
2416 {
2417 if(strcmp("navigationInterface", $padre->node_name())!=0)
2418 {
2419 $error->type = "position_error";
2420 $error->data->tag = $nome_figlio;
2421 $error->data->parent = $padre->node_name();
2422 array_push($errors, $error);
2423 $cont_err++;
2424 }
2425 if($figlio->has_child_nodes())
2426 {
2427 $hide_children = $figlio->child_nodes();
2428 $cont_hide = count($hide_children);
2429 if($cont_hide > 4)
2430 {
2431 $error->type = "too_many_attributes";
2432 $error->data->tag = $nome_figlio;
2433 array_push($errors, $error);
2434 $cont_err++;
2435 }
2436 for($i=0; $i < $cont_hide; $i++)
2437 {
2438 $hch_t = $hide_children[$i]->node_type();
2439 $hch_cont = $hide_children[$i]->get_content();
2440 if(($hch_t == 3)&&(is_hch_cont($hch_cont)))
2441 {
2442 //echo "OK, SCANSIONE TAG HIDELMSUI TERMINATA";
2443 }
2444 else
2445 {
2446 $error->type = "tag_error";
2447 $error->data->tag = $nome_figlio;
2448 $error->data->value = $hch_cont;
2449 array_push($errors, $error);
2450 $cont_err++;
2451 }
2452 }
2453 }
2454 }
2455 }
2456
2457 }// END IF FIGLIO
2458 if($figlio->has_child_nodes())
2459 {
2460 testNode($figlio); //Ricorsione sui nodi figli
2461 }
2462 $figlio = $figlio->next_sibling();
2463 }
2464 }
2465
2466 if(count($errors) > 0)
2467 {
2468 return false;
2469 }
2470 else return true;
2471 }
2472
2473
2474 ?>
Read-only mirror of the Moodle CVS