1
2
3
4
5
6
7
8 package org.codehaus.plexus.security.authorization.rbac.jdo.v0_9_0.io.stax;
9
10
11
12
13
14 import java.io.ByteArrayInputStream;
15 import java.io.File;
16 import java.io.FileInputStream;
17 import java.io.IOException;
18 import java.io.InputStreamReader;
19 import java.io.Reader;
20 import java.io.StringReader;
21 import java.io.StringWriter;
22 import java.text.DateFormat;
23 import java.text.ParsePosition;
24 import java.util.Locale;
25 import java.util.regex.Matcher;
26 import java.util.regex.Pattern;
27 import javax.xml.stream.*;
28 import org.codehaus.plexus.security.authorization.rbac.jdo.v0_9_0.JdoOperation;
29 import org.codehaus.plexus.security.authorization.rbac.jdo.v0_9_0.JdoPermission;
30 import org.codehaus.plexus.security.authorization.rbac.jdo.v0_9_0.JdoResource;
31 import org.codehaus.plexus.security.authorization.rbac.jdo.v0_9_0.JdoRole;
32 import org.codehaus.plexus.security.authorization.rbac.jdo.v0_9_0.JdoUserAssignment;
33 import org.codehaus.plexus.security.authorization.rbac.jdo.v0_9_0.RbacDatabase;
34 import org.codehaus.plexus.util.xml.Xpp3Dom;
35
36
37
38
39
40
41 public class RbacJdoModelStaxReader
42 {
43
44
45
46
47
48
49
50
51 private java.util.Map jdoPermissionReferences;
52
53
54
55
56 private java.util.Map jdoPermissionInstances;
57
58
59
60
61 private java.util.Map jdoOperationReferences;
62
63
64
65
66 private java.util.Map jdoResourceReferences;
67
68
69
70
71 private java.util.Map jdoOperationInstances;
72
73
74
75
76 private java.util.Map jdoResourceInstances;
77
78
79
80
81
82
83
84
85
86
87
88
89
90 private Xpp3Dom buildDom( XMLStreamReader xmlStreamReader )
91 throws XMLStreamException
92 {
93 java.util.List elements = new java.util.ArrayList();
94 java.util.List values = new java.util.ArrayList();
95 int eventType = xmlStreamReader.getEventType();
96 while ( xmlStreamReader.hasNext() )
97 {
98 if ( eventType == XMLStreamConstants.START_ELEMENT )
99 {
100 String rawName = xmlStreamReader.getLocalName();
101 Xpp3Dom childConfiguration = new Xpp3Dom( rawName );
102 int depth = elements.size();
103 if ( depth > 0 )
104 {
105 Xpp3Dom parent = (Xpp3Dom) elements.get( depth - 1 );
106 parent.addChild( childConfiguration );
107 }
108 elements.add( childConfiguration );
109 if ( xmlStreamReader.isEndElement() )
110 {
111 values.add( null );
112 }
113 else
114 {
115 values.add( new StringBuffer() );
116 }
117 int attributesSize = xmlStreamReader.getAttributeCount();
118 for ( int i = 0; i < attributesSize; i++ )
119 {
120 String name = xmlStreamReader.getAttributeLocalName( i );
121 String value = xmlStreamReader.getAttributeValue( i );
122 childConfiguration.setAttribute( name, value );
123 }
124 }
125 else if ( eventType == XMLStreamConstants.CHARACTERS )
126 {
127 int depth = values.size() - 1;
128 StringBuffer valueBuffer = (StringBuffer) values.get( depth );
129 String text = xmlStreamReader.getText();
130 text = text.trim();
131 valueBuffer.append( text );
132 }
133 else if ( eventType == XMLStreamConstants.END_ELEMENT )
134 {
135 int depth = elements.size() - 1;
136 Xpp3Dom finishedConfiguration = (Xpp3Dom) elements.remove( depth );
137
138 Object accumulatedValue = values.remove( depth );
139 if ( finishedConfiguration.getChildCount() == 0 )
140 {
141 if ( accumulatedValue == null )
142 {
143 finishedConfiguration.setValue( null );
144 }
145 else
146 {
147 finishedConfiguration.setValue( accumulatedValue.toString() );
148 }
149 }
150 if ( depth == 0 )
151 {
152 return finishedConfiguration;
153 }
154 }
155 eventType = xmlStreamReader.next();
156 }
157 throw new IllegalStateException( "End of document found before returning to 0 depth" );
158 }
159
160
161
162
163
164
165
166
167
168
169
170 private boolean checkFieldWithDuplicate( XMLStreamReader xmlStreamReader, String tagName, String alias, java.util.Set parsed )
171 throws XMLStreamException
172 {
173 if ( !( xmlStreamReader.getLocalName().equals( tagName ) || xmlStreamReader.getLocalName().equals( alias ) ) )
174 {
175 return false;
176 }
177 if ( parsed.contains( tagName ) )
178 {
179 throw new XMLStreamException( "Duplicated tag: '" + tagName + "'", xmlStreamReader.getLocation() );
180 }
181 parsed.add( tagName );
182 return true;
183 }
184
185
186
187
188
189
190
191
192
193
194 private boolean getBooleanValue( String s, String attribute, XMLStreamReader xmlStreamReader )
195 throws XMLStreamException
196 {
197 if ( s != null )
198 {
199 return Boolean.valueOf( s ).booleanValue();
200 }
201 return false;
202 }
203
204
205
206
207
208
209
210
211
212
213
214 private byte getByteValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
215 throws XMLStreamException
216 {
217 if ( s != null )
218 {
219 try
220 {
221 return Byte.valueOf( s ).byteValue();
222 }
223 catch ( NumberFormatException e )
224 {
225 if ( strict )
226 {
227 throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be a byte but was '" + s + "'", xmlStreamReader.getLocation() );
228 }
229 }
230 }
231 return 0;
232 }
233
234
235
236
237
238
239
240
241
242
243 private char getCharacterValue( String s, String attribute, XMLStreamReader xmlStreamReader )
244 throws XMLStreamException
245 {
246 if ( s != null )
247 {
248 return s.charAt( 0 );
249 }
250 return 0;
251 }
252
253
254
255
256
257
258
259
260
261
262
263 private java.util.Date getDateValue( String s, String attribute, String dateFormat, XMLStreamReader xmlStreamReader )
264 throws XMLStreamException
265 {
266 if ( s != null )
267 {
268 String effectiveDateFormat = dateFormat;
269 if ( dateFormat == null )
270 {
271 effectiveDateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSS";
272 }
273 if ( "long".equals( effectiveDateFormat ) )
274 {
275 try
276 {
277 return new java.util.Date( Long.parseLong( s ) );
278 }
279 catch ( NumberFormatException e )
280 {
281 throw new XMLStreamException( e.getMessage() );
282 }
283 }
284 else
285 {
286 try
287 {
288 DateFormat dateParser = new java.text.SimpleDateFormat( effectiveDateFormat, Locale.US );
289 return dateParser.parse( s );
290 }
291 catch ( java.text.ParseException e )
292 {
293 throw new XMLStreamException( e.getMessage() );
294 }
295 }
296 }
297 return null;
298 }
299
300
301
302
303
304
305
306
307 private String getDefaultValue( String s, String v )
308 {
309 if ( s == null )
310 {
311 s = v;
312 }
313 return s;
314 }
315
316
317
318
319
320
321
322
323
324
325
326 private double getDoubleValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
327 throws XMLStreamException
328 {
329 if ( s != null )
330 {
331 try
332 {
333 return Double.valueOf( s ).doubleValue();
334 }
335 catch ( NumberFormatException e )
336 {
337 if ( strict )
338 {
339 throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be a floating point number but was '" + s + "'", xmlStreamReader.getLocation() );
340 }
341 }
342 }
343 return 0;
344 }
345
346
347
348
349
350
351
352
353
354
355
356 private float getFloatValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
357 throws XMLStreamException
358 {
359 if ( s != null )
360 {
361 try
362 {
363 return Float.valueOf( s ).floatValue();
364 }
365 catch ( NumberFormatException e )
366 {
367 if ( strict )
368 {
369 throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be a floating point number but was '" + s + "'", xmlStreamReader.getLocation() );
370 }
371 }
372 }
373 return 0;
374 }
375
376
377
378
379
380
381
382
383
384
385
386 private int getIntegerValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
387 throws XMLStreamException
388 {
389 if ( s != null )
390 {
391 try
392 {
393 return Integer.valueOf( s ).intValue();
394 }
395 catch ( NumberFormatException e )
396 {
397 if ( strict )
398 {
399 throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be an integer but was '" + s + "'", xmlStreamReader.getLocation() );
400 }
401 }
402 }
403 return 0;
404 }
405
406
407
408
409
410
411
412
413
414
415
416 private long getLongValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
417 throws XMLStreamException
418 {
419 if ( s != null )
420 {
421 try
422 {
423 return Long.valueOf( s ).longValue();
424 }
425 catch ( NumberFormatException e )
426 {
427 if ( strict )
428 {
429 throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be a long integer but was '" + s + "'", xmlStreamReader.getLocation() );
430 }
431 }
432 }
433 return 0;
434 }
435
436
437
438
439
440
441
442
443
444
445
446 private String getRequiredAttributeValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
447 throws XMLStreamException
448 {
449 if ( s == null )
450 {
451 if ( strict )
452 {
453 throw new XMLStreamException( "Missing required value for attribute '" + attribute + "'", xmlStreamReader.getLocation() );
454 }
455 }
456 return s;
457 }
458
459
460
461
462
463
464
465
466
467
468
469 private short getShortValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
470 throws XMLStreamException
471 {
472 if ( s != null )
473 {
474 try
475 {
476 return Short.valueOf( s ).shortValue();
477 }
478 catch ( NumberFormatException e )
479 {
480 if ( strict )
481 {
482 throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be a short integer but was '" + s + "'", xmlStreamReader.getLocation() );
483 }
484 }
485 }
486 return 0;
487 }
488
489
490
491
492
493
494
495 private String getTrimmedValue( String s )
496 {
497 if ( s != null )
498 {
499 s = s.trim();
500 }
501 return s;
502 }
503
504
505
506
507
508
509
510
511
512
513
514
515 private JdoOperation parseJdoOperation( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
516 throws IOException, XMLStreamException
517 {
518 JdoOperation jdoOperation = new JdoOperation();
519 java.util.Set parsed = new java.util.HashSet();
520 if ( jdoOperationInstances == null )
521 {
522 jdoOperationInstances = new java.util.HashMap();
523 }
524 String v = xmlStreamReader.getAttributeValue( null, "modello.id" );
525 if ( v != null )
526 {
527 jdoOperationInstances.put( v, jdoOperation );
528 }
529 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
530 {
531 if ( checkFieldWithDuplicate( xmlStreamReader, "name", null, parsed ) )
532 {
533 jdoOperation.setName( getTrimmedValue( xmlStreamReader.getElementText() ) );
534 }
535 else if ( checkFieldWithDuplicate( xmlStreamReader, "description", null, parsed ) )
536 {
537 jdoOperation.setDescription( getTrimmedValue( xmlStreamReader.getElementText() ) );
538 }
539 else if ( checkFieldWithDuplicate( xmlStreamReader, "permanent", null, parsed ) )
540 {
541 jdoOperation.setPermanent( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "permanent", xmlStreamReader ) );
542 }
543 else if ( checkFieldWithDuplicate( xmlStreamReader, "resourceRequired", null, parsed ) )
544 {
545 jdoOperation.setResourceRequired( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "resourceRequired", xmlStreamReader ) );
546 }
547 else
548 {
549 if ( strict )
550 {
551 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
552 }
553 else
554 {
555 int unrecognizedTagCount = 1;
556 while( unrecognizedTagCount != 0 )
557 {
558 xmlStreamReader.next();
559 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
560 {
561 unrecognizedTagCount++;
562 }
563 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
564 {
565 unrecognizedTagCount--;
566 }
567 }
568 }
569 }
570 }
571 jdoOperationInstances.put( jdoOperation.getName(), jdoOperation );
572 return jdoOperation;
573 }
574
575
576
577
578
579
580
581
582
583
584
585
586 private JdoPermission parseJdoPermission( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
587 throws IOException, XMLStreamException
588 {
589 JdoPermission jdoPermission = new JdoPermission();
590 java.util.Set parsed = new java.util.HashSet();
591 if ( jdoPermissionInstances == null )
592 {
593 jdoPermissionInstances = new java.util.HashMap();
594 }
595 String v = xmlStreamReader.getAttributeValue( null, "modello.id" );
596 if ( v != null )
597 {
598 jdoPermissionInstances.put( v, jdoPermission );
599 }
600 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
601 {
602 if ( checkFieldWithDuplicate( xmlStreamReader, "name", null, parsed ) )
603 {
604 jdoPermission.setName( getTrimmedValue( xmlStreamReader.getElementText() ) );
605 }
606 else if ( checkFieldWithDuplicate( xmlStreamReader, "description", null, parsed ) )
607 {
608 jdoPermission.setDescription( getTrimmedValue( xmlStreamReader.getElementText() ) );
609 }
610 else if ( checkFieldWithDuplicate( xmlStreamReader, "permanent", null, parsed ) )
611 {
612 jdoPermission.setPermanent( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "permanent", xmlStreamReader ) );
613 }
614 else if ( checkFieldWithDuplicate( xmlStreamReader, "operation", null, parsed ) )
615 {
616 String value = xmlStreamReader.getAttributeValue( null, "name" );
617 if ( value != null )
618 {
619
620 if ( jdoOperationReferences == null )
621 {
622 jdoOperationReferences = new java.util.HashMap();
623 }
624 java.util.Map refs = (java.util.Map) jdoOperationReferences.get( jdoPermission );
625 if ( refs == null )
626 {
627 refs = new java.util.HashMap();
628 jdoOperationReferences.put( jdoPermission, refs );
629 }
630 refs.put( "operation", value );
631 }
632 while ( xmlStreamReader.getEventType() != XMLStreamConstants.END_ELEMENT )
633 {
634 xmlStreamReader.next();
635 }
636 }
637 else if ( checkFieldWithDuplicate( xmlStreamReader, "resource", null, parsed ) )
638 {
639 String value = xmlStreamReader.getAttributeValue( null, "identifier" );
640 if ( value != null )
641 {
642
643 if ( jdoResourceReferences == null )
644 {
645 jdoResourceReferences = new java.util.HashMap();
646 }
647 java.util.Map refs = (java.util.Map) jdoResourceReferences.get( jdoPermission );
648 if ( refs == null )
649 {
650 refs = new java.util.HashMap();
651 jdoResourceReferences.put( jdoPermission, refs );
652 }
653 refs.put( "resource", value );
654 }
655 while ( xmlStreamReader.getEventType() != XMLStreamConstants.END_ELEMENT )
656 {
657 xmlStreamReader.next();
658 }
659 }
660 else
661 {
662 if ( strict )
663 {
664 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
665 }
666 else
667 {
668 int unrecognizedTagCount = 1;
669 while( unrecognizedTagCount != 0 )
670 {
671 xmlStreamReader.next();
672 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
673 {
674 unrecognizedTagCount++;
675 }
676 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
677 {
678 unrecognizedTagCount--;
679 }
680 }
681 }
682 }
683 }
684 jdoPermissionInstances.put( jdoPermission.getName(), jdoPermission );
685 return jdoPermission;
686 }
687
688
689
690
691
692
693
694
695
696
697
698
699 private JdoResource parseJdoResource( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
700 throws IOException, XMLStreamException
701 {
702 JdoResource jdoResource = new JdoResource();
703 java.util.Set parsed = new java.util.HashSet();
704 if ( jdoResourceInstances == null )
705 {
706 jdoResourceInstances = new java.util.HashMap();
707 }
708 String v = xmlStreamReader.getAttributeValue( null, "modello.id" );
709 if ( v != null )
710 {
711 jdoResourceInstances.put( v, jdoResource );
712 }
713 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
714 {
715 if ( checkFieldWithDuplicate( xmlStreamReader, "identifier", null, parsed ) )
716 {
717 jdoResource.setIdentifier( getTrimmedValue( xmlStreamReader.getElementText() ) );
718 }
719 else if ( checkFieldWithDuplicate( xmlStreamReader, "pattern", null, parsed ) )
720 {
721 jdoResource.setPattern( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "pattern", xmlStreamReader ) );
722 }
723 else if ( checkFieldWithDuplicate( xmlStreamReader, "permanent", null, parsed ) )
724 {
725 jdoResource.setPermanent( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "permanent", xmlStreamReader ) );
726 }
727 else
728 {
729 if ( strict )
730 {
731 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
732 }
733 else
734 {
735 int unrecognizedTagCount = 1;
736 while( unrecognizedTagCount != 0 )
737 {
738 xmlStreamReader.next();
739 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
740 {
741 unrecognizedTagCount++;
742 }
743 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
744 {
745 unrecognizedTagCount--;
746 }
747 }
748 }
749 }
750 }
751 jdoResourceInstances.put( jdoResource.getIdentifier(), jdoResource );
752 return jdoResource;
753 }
754
755
756
757
758
759
760
761
762
763
764
765
766 private JdoRole parseJdoRole( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
767 throws IOException, XMLStreamException
768 {
769 JdoRole jdoRole = new JdoRole();
770 java.util.Set parsed = new java.util.HashSet();
771 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
772 {
773 if ( checkFieldWithDuplicate( xmlStreamReader, "name", null, parsed ) )
774 {
775 jdoRole.setName( getTrimmedValue( xmlStreamReader.getElementText() ) );
776 }
777 else if ( checkFieldWithDuplicate( xmlStreamReader, "description", null, parsed ) )
778 {
779 jdoRole.setDescription( getTrimmedValue( xmlStreamReader.getElementText() ) );
780 }
781 else if ( checkFieldWithDuplicate( xmlStreamReader, "assignable", null, parsed ) )
782 {
783 jdoRole.setAssignable( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "assignable", xmlStreamReader ) );
784 }
785 else if ( checkFieldWithDuplicate( xmlStreamReader, "permanent", null, parsed ) )
786 {
787 jdoRole.setPermanent( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "permanent", xmlStreamReader ) );
788 }
789 else if ( checkFieldWithDuplicate( xmlStreamReader, "childRoleNames", null, parsed ) )
790 {
791 java.util.List childRoleNames = new java.util.ArrayList
792 jdoRole.setChildRoleNames( childRoleNames );
793 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
794 {
795 if ( xmlStreamReader.getLocalName().equals( "childRoleName" ) )
796 {
797 childRoleNames.add( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "new java.util.ArrayList/*<String>*/()" ) ) );
798 }
799 else
800 {
801 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
802 }
803 }
804 }
805 else if ( checkFieldWithDuplicate( xmlStreamReader, "permissions", null, parsed ) )
806 {
807 java.util.List permissions = new java.util.ArrayList
808 jdoRole.setPermissions( permissions );
809 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
810 {
811 if ( xmlStreamReader.getLocalName().equals( "permission" ) )
812 {
813 String value = xmlStreamReader.getAttributeValue( null, "name" );
814 if ( value != null )
815 {
816
817 if ( jdoPermissionReferences == null )
818 {
819 jdoPermissionReferences = new java.util.HashMap();
820 }
821 java.util.Map refs = (java.util.Map) jdoPermissionReferences.get( jdoRole );
822 if ( refs == null )
823 {
824 refs = new java.util.HashMap();
825 jdoPermissionReferences.put( jdoRole, refs );
826 }
827 refs.put( "permissions." + permissions.size(), value );
828 }
829 jdoRole.addPermission( parseJdoPermission( "permission", xmlStreamReader, strict, encoding ) );
830 }
831 else
832 {
833 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
834 }
835 }
836 }
837 else
838 {
839 if ( strict )
840 {
841 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
842 }
843 else
844 {
845 int unrecognizedTagCount = 1;
846 while( unrecognizedTagCount != 0 )
847 {
848 xmlStreamReader.next();
849 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
850 {
851 unrecognizedTagCount++;
852 }
853 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
854 {
855 unrecognizedTagCount--;
856 }
857 }
858 }
859 }
860 }
861 return jdoRole;
862 }
863
864
865
866
867
868
869
870
871
872
873
874
875 private JdoUserAssignment parseJdoUserAssignment( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
876 throws IOException, XMLStreamException
877 {
878 JdoUserAssignment jdoUserAssignment = new JdoUserAssignment();
879 java.util.Set parsed = new java.util.HashSet();
880 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
881 {
882 if ( checkFieldWithDuplicate( xmlStreamReader, "principal", null, parsed ) )
883 {
884 jdoUserAssignment.setPrincipal( getTrimmedValue( xmlStreamReader.getElementText() ) );
885 }
886 else if ( checkFieldWithDuplicate( xmlStreamReader, "timestamp", null, parsed ) )
887 {
888 String dateFormat = null;
889 jdoUserAssignment.setTimestamp( getDateValue( getTrimmedValue( xmlStreamReader.getElementText() ), "timestamp", dateFormat, xmlStreamReader ) );
890 }
891 else if ( checkFieldWithDuplicate( xmlStreamReader, "permanent", null, parsed ) )
892 {
893 jdoUserAssignment.setPermanent( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "permanent", xmlStreamReader ) );
894 }
895 else if ( checkFieldWithDuplicate( xmlStreamReader, "roleNames", null, parsed ) )
896 {
897 java.util.List roleNames = new java.util.ArrayList
898 jdoUserAssignment.setRoleNames( roleNames );
899 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
900 {
901 if ( xmlStreamReader.getLocalName().equals( "roleName" ) )
902 {
903 roleNames.add( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "new java.util.ArrayList/*<String>*/()" ) ) );
904 }
905 else
906 {
907 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
908 }
909 }
910 }
911 else
912 {
913 if ( strict )
914 {
915 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
916 }
917 else
918 {
919 int unrecognizedTagCount = 1;
920 while( unrecognizedTagCount != 0 )
921 {
922 xmlStreamReader.next();
923 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
924 {
925 unrecognizedTagCount++;
926 }
927 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
928 {
929 unrecognizedTagCount--;
930 }
931 }
932 }
933 }
934 }
935 return jdoUserAssignment;
936 }
937
938
939
940
941
942
943
944
945
946
947
948
949 private RbacDatabase parseRbacDatabase( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
950 throws IOException, XMLStreamException
951 {
952 RbacDatabase rbacDatabase = new RbacDatabase();
953 java.util.Set parsed = new java.util.HashSet();
954 rbacDatabase.setModelEncoding( encoding );
955 boolean foundRoot = false;
956 while ( xmlStreamReader.hasNext() )
957 {
958 int eventType = xmlStreamReader.next();
959 if ( eventType == XMLStreamConstants.START_ELEMENT )
960 {
961 if ( xmlStreamReader.getLocalName().equals( tagName ) )
962 {
963 foundRoot = true;
964 }
965 else if ( checkFieldWithDuplicate( xmlStreamReader, "roles", null, parsed ) )
966 {
967 java.util.List roles = new java.util.ArrayList
968 rbacDatabase.setRoles( roles );
969 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
970 {
971 if ( xmlStreamReader.getLocalName().equals( "role" ) )
972 {
973 rbacDatabase.addRole( parseJdoRole( "role", xmlStreamReader, strict, encoding ) );
974 }
975 else
976 {
977 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
978 }
979 }
980 }
981 else if ( checkFieldWithDuplicate( xmlStreamReader, "permissions", null, parsed ) )
982 {
983 java.util.List permissions = new java.util.ArrayList
984 rbacDatabase.setPermissions( permissions );
985 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
986 {
987 if ( xmlStreamReader.getLocalName().equals( "permission" ) )
988 {
989 rbacDatabase.addPermission( parseJdoPermission( "permission", xmlStreamReader, strict, encoding ) );
990 }
991 else
992 {
993 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
994 }
995 }
996 }
997 else if ( checkFieldWithDuplicate( xmlStreamReader, "operations", null, parsed ) )
998 {
999 java.util.List operations = new java.util.ArrayList
1000 rbacDatabase.setOperations( operations );
1001 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1002 {
1003 if ( xmlStreamReader.getLocalName().equals( "operation" ) )
1004 {
1005 rbacDatabase.addOperation( parseJdoOperation( "operation", xmlStreamReader, strict, encoding ) );
1006 }
1007 else
1008 {
1009 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1010 }
1011 }
1012 }
1013 else if ( checkFieldWithDuplicate( xmlStreamReader, "resources", null, parsed ) )
1014 {
1015 java.util.List resources = new java.util.ArrayList
1016 rbacDatabase.setResources( resources );
1017 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1018 {
1019 if ( xmlStreamReader.getLocalName().equals( "resource" ) )
1020 {
1021 rbacDatabase.addResource( parseJdoResource( "resource", xmlStreamReader, strict, encoding ) );
1022 }
1023 else
1024 {
1025 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1026 }
1027 }
1028 }
1029 else if ( checkFieldWithDuplicate( xmlStreamReader, "userAssignments", null, parsed ) )
1030 {
1031 java.util.List userAssignments = new java.util.ArrayList
1032 rbacDatabase.setUserAssignments( userAssignments );
1033 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1034 {
1035 if ( xmlStreamReader.getLocalName().equals( "userAssignment" ) )
1036 {
1037 rbacDatabase.addUserAssignment( parseJdoUserAssignment( "userAssignment", xmlStreamReader, strict, encoding ) );
1038 }
1039 else
1040 {
1041 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1042 }
1043 }
1044 }
1045 else
1046 {
1047 if ( foundRoot )
1048 {
1049 if ( strict )
1050 {
1051 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1052 }
1053 }
1054 }
1055 }
1056 }
1057 return rbacDatabase;
1058 }
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069 public RbacDatabase read( Reader reader, boolean strict )
1070 throws IOException, XMLStreamException
1071 {
1072 XMLStreamReader xmlStreamReader = XMLInputFactory.newInstance().createXMLStreamReader( reader );
1073
1074 String encoding = xmlStreamReader.getCharacterEncodingScheme();
1075 RbacDatabase value = parseRbacDatabase( "rbacDatabase", xmlStreamReader, strict, encoding );
1076 resolveReferences( value );
1077 return value;
1078 }
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088 public RbacDatabase read( Reader reader )
1089 throws IOException, XMLStreamException
1090 {
1091 return read( reader, true );
1092 }
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103 public RbacDatabase read( String filePath, boolean strict )
1104 throws IOException, XMLStreamException
1105 {
1106 File file = new File(filePath);
1107 XMLStreamReader xmlStreamReader = XMLInputFactory.newInstance().createXMLStreamReader( file.toURL().toExternalForm(), new FileInputStream(file) );
1108
1109 String encoding = xmlStreamReader.getCharacterEncodingScheme();
1110 RbacDatabase value = parseRbacDatabase( "rbacDatabase", xmlStreamReader, strict, encoding );
1111 resolveReferences( value );
1112 return value;
1113 }
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123 public RbacDatabase read( String filePath )
1124 throws IOException, XMLStreamException
1125 {
1126 return read( filePath, true );
1127 }
1128
1129
1130
1131
1132
1133
1134 private void resolveReferences( RbacDatabase value )
1135 {
1136 java.util.Map refs;
1137 for ( java.util.Iterator i = value.getRoles().iterator(); i.hasNext(); )
1138 {
1139 resolveReferences( (JdoRole) i.next() );
1140 }
1141 for ( java.util.Iterator i = value.getPermissions().iterator(); i.hasNext(); )
1142 {
1143 resolveReferences( (JdoPermission) i.next() );
1144 }
1145 }
1146
1147
1148
1149
1150
1151
1152 private void resolveReferences( JdoRole value )
1153 {
1154 java.util.Map refs;
1155 if ( jdoPermissionReferences != null )
1156 {
1157 refs = (java.util.Map) jdoPermissionReferences.get( value );
1158 if ( refs != null )
1159 {
1160 for ( int i = 0; i < value.getPermissions().size(); i++ )
1161 {
1162 String id = (String) refs.get( "permissions." + i );
1163 JdoPermission ref = (JdoPermission) jdoPermissionInstances.get( id );
1164 if ( ref != null )
1165 {
1166 value.getPermissions().set( i, ref );
1167 }
1168 }
1169 }
1170 }
1171 }
1172
1173
1174
1175
1176
1177
1178 private void resolveReferences( JdoPermission value )
1179 {
1180 java.util.Map refs;
1181 if ( jdoOperationReferences != null )
1182 {
1183 refs = (java.util.Map) jdoOperationReferences.get( value );
1184 if ( refs != null )
1185 {
1186 String id = (String) refs.get( "operation" );
1187 JdoOperation ref = (JdoOperation) jdoOperationInstances.get( id );
1188 if ( ref != null && !ref.equals( value.getOperation() ) )
1189 {
1190 value.setOperation( ref );
1191 }
1192 }
1193 }
1194 if ( jdoResourceReferences != null )
1195 {
1196 refs = (java.util.Map) jdoResourceReferences.get( value );
1197 if ( refs != null )
1198 {
1199 String id = (String) refs.get( "resource" );
1200 JdoResource ref = (JdoResource) jdoResourceInstances.get( id );
1201 if ( ref != null && !ref.equals( value.getResource() ) )
1202 {
1203 value.setResource( ref );
1204 }
1205 }
1206 }
1207 }
1208
1209 }