1 package org.andromda.cartridges.webservice;
2
3 import java.util.ArrayList;
4 import java.util.Collection;
5 import java.util.Collections;
6 import java.util.Date;
7 import java.util.HashSet;
8 import java.util.LinkedHashSet;
9 import java.util.List;
10 import java.util.Map;
11 import java.util.Set;
12 import java.util.TreeMap;
13 import java.util.TreeSet;
14 import org.andromda.cartridges.webservice.metafacades.WSDLEnumerationType;
15 import org.andromda.cartridges.webservice.metafacades.WSDLEnumerationTypeLogic;
16 import org.andromda.cartridges.webservice.metafacades.WSDLType;
17 import org.andromda.cartridges.webservice.metafacades.WSDLTypeAssociationEnd;
18 import org.andromda.cartridges.webservice.metafacades.WSDLTypeAssociationEndLogic;
19 import org.andromda.cartridges.webservice.metafacades.WSDLTypeAttributeLogic;
20 import org.andromda.cartridges.webservice.metafacades.WSDLTypeLogic;
21 import org.andromda.cartridges.webservice.metafacades.WebServiceLogicImpl;
22 import org.andromda.cartridges.webservice.metafacades.WebServiceLogicImpl.OperationNameComparator;
23 import org.andromda.cartridges.webservice.metafacades.WebServiceOperation;
24 import org.andromda.cartridges.webservice.metafacades.WebServiceParameterLogic;
25 import org.andromda.core.common.Introspector;
26 import org.andromda.core.metafacade.MetafacadeBase;
27 import org.andromda.core.metafacade.MetafacadeException;
28 import org.andromda.metafacades.uml.AssociationEndFacade;
29 import org.andromda.metafacades.uml.AttributeFacade;
30 import org.andromda.metafacades.uml.ClassifierFacade;
31 import org.andromda.metafacades.uml.DependencyFacade;
32 import org.andromda.metafacades.uml.EnumerationFacade;
33 import org.andromda.metafacades.uml.EnumerationLiteralFacade;
34 import org.andromda.metafacades.uml.GeneralizableElementFacade;
35 import org.andromda.metafacades.uml.ModelElementFacade;
36 import org.andromda.metafacades.uml.OperationFacade;
37 import org.andromda.metafacades.uml.PackageFacade;
38 import org.andromda.metafacades.uml.ParameterFacade;
39 import org.andromda.metafacades.uml.Role;
40 import org.andromda.metafacades.uml.Service;
41 import org.andromda.metafacades.uml.TypeMappings;
42 import org.andromda.metafacades.uml.UMLProfile;
43 import org.apache.commons.collections.Closure;
44 import org.apache.commons.collections.CollectionUtils;
45 import org.apache.commons.lang.StringUtils;
46 import org.apache.commons.lang.time.FastDateFormat;
47 import org.apache.log4j.Logger;
48
49
50
51
52
53
54
55 public class WebServiceUtils
56 {
57
58
59
60 private static final Logger logger = Logger.getLogger(WebServiceUtils.class);
61
62
63
64
65
66
67
68 public Collection<Role> getAllRoles(Collection<Service> services)
69 {
70 final Collection<Role> allRoles = new LinkedHashSet<Role>();
71 CollectionUtils.forAllDo(services, new Closure()
72 {
73 public void execute(Object object)
74 {
75 if (object != null && Service.class.isAssignableFrom(object.getClass()))
76 {
77 allRoles.addAll(((Service)object).getAllRoles());
78 }
79 }
80 });
81 return allRoles;
82 }
83
84
85
86
87 private static Map<PackageFacade, String> packageAbbr = new TreeMap<PackageFacade, String>();
88
89
90
91
92
93
94
95
96
97
98 public Collection<PackageFacade> getPackages(WebServiceLogicImpl service, Set<ModelElementFacade> types, boolean follow)
99 {
100 return setPkgAbbr(service, types, follow);
101 }
102
103
104
105
106
107
108
109 public Map<PackageFacade, String> addPkgAbbr(PackageFacade pkg, String pkgAbbr)
110 {
111 if (packageAbbr==null)
112 {
113 packageAbbr = new TreeMap<PackageFacade, String>();
114 }
115 if (pkg!=null && pkg.getFullyQualifiedName().indexOf('.') > 0)
116 {
117 if (packageAbbr.containsKey(pkg))
118 {
119 logger.debug(pkg + " abbreviation " + pkgAbbr + " already exists in Package namespace Map");
120 }
121 else
122 {
123 packageAbbr.put(pkg, pkgAbbr);
124 }
125 }
126 return packageAbbr;
127 }
128
129
130
131
132
133
134 public String getPkgAbbr(PackageFacade pkg)
135 {
136 return this.getPkgAbbr(pkg, null);
137 }
138
139
140
141
142
143
144
145 public String getPkgAbbr(PackageFacade pkg, PackageFacade currentPackage)
146 {
147 if (pkg==null)
148 {
149 logger.error("getPkgAbbr Null pkg " + packageAbbr.size() + ": " + packageAbbr);
150 return "impl";
151 }
152 if (currentPackage != null && pkg.getFullyQualifiedName().equals(currentPackage.getFullyQualifiedName()))
153 {
154 return "impl";
155 }
156 if (packageAbbr==null)
157 {
158 packageAbbr = new TreeMap<PackageFacade, String>();
159 }
160 String rtn = packageAbbr.get(pkg);
161 String pkgName = pkg.getFullyQualifiedName();
162 if (StringUtils.isEmpty(pkgName) || pkgName.startsWith("java.lang") || pkgName.startsWith("java.util")
163 || pkgName.endsWith("PrimitiveTypes") || pkgName.endsWith("datatype"))
164 {
165
166 rtn="xs";
167 }
168 if (logger.isDebugEnabled())
169 {
170 logger.debug("getPkgAbbr " + pkg + ' ' + rtn + ' ' + packageAbbr.size() + ' ' + pkgName);
171 }
172 if (StringUtils.isEmpty(rtn))
173 {
174 rtn = (String)pkg.findTaggedValue(WebServiceGlobals.XML_XMLNS);
175 if (StringUtils.isEmpty(rtn))
176 {
177
178 int namespaceCount = packageAbbr.size()+1;
179 rtn = "ns" + namespaceCount;
180 }
181 packageAbbr.put(pkg, rtn);
182 if (logger.isDebugEnabled())
183 {
184 logger.debug("getPkgAbbr " + pkg + ' ' + rtn + ' ' + packageAbbr.size());
185 }
186 if (logger.isDebugEnabled())
187 {
188 logger.debug("Missing PkgAbbr for " + pkgName + ": added " + rtn);
189 }
190 }
191 return rtn;
192 }
193
194
195
196
197
198
199
200
201 private Set<PackageFacade> setPkgAbbr(WebServiceLogicImpl service, Set<ModelElementFacade> types, boolean follow)
202 {
203
204 Set<PackageFacade> pkgSet = new TreeSet<PackageFacade>();
205 if (logger.isDebugEnabled())
206 {
207 logger.debug(service.getName() + " setPkgAbbr");
208 }
209 int namespaceCount = packageAbbr.size() + 1;
210 PackageFacade pkg = (PackageFacade) service.getPackage();
211 String name = null;
212 if (pkg!=null && pkg.getFullyQualifiedName().indexOf('.') > 0)
213 {
214 if (!pkgSet.contains(pkg))
215 {
216 pkgSet.add(pkg);
217 }
218 if (!packageAbbr.containsKey(pkg))
219 {
220 packageAbbr.put(pkg, "ns" + namespaceCount);
221 if (logger.isDebugEnabled())
222 {
223 logger.debug(service.getName() + " ns" + namespaceCount + ' ' + pkg + ' ' + service.getName() + " servicePackage");
224 }
225 namespaceCount++;
226 }
227 }
228
229 for (final WebServiceOperation op : service.getAllowedOperations())
230 {
231 for (final ModelElementFacade arg : (Collection<ModelElementFacade>)op.getExceptions())
232 {
233 pkg = (PackageFacade) arg.getPackage();
234 if (pkg!=null && pkg.getFullyQualifiedName().indexOf('.') > 0)
235 {
236 if (!pkgSet.contains(pkg))
237 {
238 pkgSet.add(pkg);
239 }
240 if (!packageAbbr.containsKey(pkg))
241 {
242 packageAbbr.put(pkg, "ns" + namespaceCount);
243 if (logger.isDebugEnabled())
244 {
245 logger.debug(service.getName() + " ns" + namespaceCount + ' ' + pkg + ' ' + op.getName() + " getExceptions " + arg.getName());
246 }
247 namespaceCount++;
248 }
249 }
250 }
251 for (final ParameterFacade arg : op.getParameters())
252 {
253 pkg = (PackageFacade) arg.getType().getPackage();
254 if (pkg!=null && pkg.getFullyQualifiedName().indexOf('.') > 0)
255 {
256 if (!pkgSet.contains(pkg))
257 {
258 pkgSet.add(pkg);
259 }
260 if (!packageAbbr.containsKey(pkg))
261 {
262 packageAbbr.put(pkg, "ns" + namespaceCount);
263 if (logger.isDebugEnabled())
264 {
265 logger.debug(service.getName() + " ns" + namespaceCount + ' ' + pkg + ' ' + op.getName() + " getParameters " + arg.getName());
266 }
267 namespaceCount++;
268 }
269 }
270 }
271 if (op.getReturnType()!=null)
272 {
273 pkg = (PackageFacade) op.getReturnType().getPackage();
274 if (pkg!=null && pkg.getFullyQualifiedName().indexOf('.') > 0)
275 {
276 if (!pkgSet.contains(pkg))
277 {
278 pkgSet.add(pkg);
279 }
280 if (!packageAbbr.containsKey(pkg))
281 {
282 packageAbbr.put(pkg, "ns" + namespaceCount);
283 if (logger.isDebugEnabled())
284 {
285 logger.debug(service.getName() + " ns" + namespaceCount + ' ' + pkg + ' ' + op.getName() + " getReturnType " + op.getReturnType().getName());
286 }
287 namespaceCount++;
288 }
289 }
290 }
291 }
292 for (final ModelElementFacade element : types)
293 {
294 ClassifierFacade facade = service.getType(element);
295 if (facade != null)
296 {
297 pkg = (PackageFacade) facade.getPackage();
298 if (logger.isDebugEnabled())
299 {
300 name = facade.getName();
301 logger.debug("setPkgAbbr facade " + pkg + '.' + name);
302 }
303 if (pkg != null && pkg.getFullyQualifiedName().indexOf('.') > 0)
304 {
305
306 for (ModelElementFacade attr : (Collection<ModelElementFacade>)facade.getProperties(follow))
307 {
308 try
309 {
310 ClassifierFacade attrType = getType(attr);
311 if (attrType != null)
312 {
313 pkg = (PackageFacade) attrType.getPackage();
314 name = attrType.getName();
315 if (pkg!=null && pkg.getFullyQualifiedName().indexOf('.') > 0)
316 {
317 if (!pkgSet.contains(pkg))
318 {
319 pkgSet.add(pkg);
320 }
321 if (!packageAbbr.containsKey(pkg))
322 {
323 packageAbbr.put(pkg, "ns" + namespaceCount);
324 if (logger.isDebugEnabled())
325 {
326 logger.debug(service.getName() + " ns" + namespaceCount + ' ' + pkg + ' ' + facade.getName());
327 }
328 namespaceCount++;
329 }
330 }
331 }
332 }
333 catch (RuntimeException e)
334 {
335 logger.debug("setPkgAbbr error in service " + service.getName() + " ns" + namespaceCount + ' ' + pkg + ' ' + facade.getName());
336 }
337 }
338 for (AssociationEndFacade otherEnd : (List<AssociationEndFacade>)facade.getNavigableConnectingEnds(follow))
339 {
340 try
341 {
342 ClassifierFacade endType = getType(otherEnd);
343 if (endType != null)
344 {
345 pkg = (PackageFacade) endType.getPackage();
346 name = endType.getName();
347 if (pkg!=null && pkg.getFullyQualifiedName().indexOf('.') > 0)
348 {
349 if (!pkgSet.contains(pkg))
350 {
351 pkgSet.add(pkg);
352 }
353 if (!packageAbbr.containsKey(pkg))
354 {
355 packageAbbr.put(pkg, "ns" + namespaceCount);
356 if (logger.isDebugEnabled())
357 {
358 logger.debug(service.getName() + " ns" + namespaceCount + ' ' + pkg + ' ' + facade.getName());
359 }
360 namespaceCount++;
361 }
362 }
363 }
364 }
365 catch (RuntimeException e)
366 {
367 logger.debug("setPkgAbbr error in service " + service.getName() + " ns" + namespaceCount + ' ' + pkg + ' ' + facade.getName());
368 }
369 }
370 }
371 }
372
373 else if (element instanceof ClassifierFacade)
374 {
375 ClassifierFacade type = (ClassifierFacade)element;
376 if (getType(type) != null)
377 {
378 type = getType(type);
379 }
380 pkg = (PackageFacade) type.getPackage();
381 if (pkg != null && pkg.getFullyQualifiedName().indexOf('.') > 0)
382 {
383
384
385
386
387
388
389
390 for (ModelElementFacade attr : (List<ModelElementFacade>)type.getProperties(follow))
391 {
392 try
393 {
394 ClassifierFacade attrType = getType(attr);
395 if (getType(attrType) != null)
396 {
397 pkg = (PackageFacade) attrType.getPackage();
398 name = attrType.getName();
399 if (pkg!=null && pkg.getFullyQualifiedName().indexOf('.') > 0)
400 {
401 if (!pkgSet.contains(pkg))
402 {
403 pkgSet.add(pkg);
404 }
405 if (!packageAbbr.containsKey(pkg))
406 {
407 packageAbbr.put(pkg, "ns" + namespaceCount);
408 if (logger.isDebugEnabled())
409 {
410 logger.debug(service.getName() + " ns" + namespaceCount + ' ' + pkg + ' ' + type.getName() + '.' + name);
411 }
412 namespaceCount++;
413 }
414 }
415 }
416 }
417 catch (RuntimeException e)
418 {
419 logger.debug("setPkgAbbr error in service " + service.getName() + " ns" + namespaceCount + ' ' + pkg + ' ' + type.getName() + ": " + e);
420 }
421 }
422 for (AssociationEndFacade otherEnd : (List<AssociationEndFacade>)type.getNavigableConnectingEnds(follow))
423 {
424 try
425 {
426 ClassifierFacade endType = getType(otherEnd);
427 if (endType != null)
428 {
429 pkg = (PackageFacade) endType.getPackage();
430 name = endType.getName();
431 if (pkg!=null && pkg.getFullyQualifiedName().indexOf('.') > 0)
432 {
433 if (!pkgSet.contains(pkg))
434 {
435 pkgSet.add(pkg);
436 }
437 if (!packageAbbr.containsKey(pkg))
438 {
439 packageAbbr.put(pkg, "ns" + namespaceCount);
440 if (logger.isDebugEnabled())
441 {
442 logger.debug(service.getName() + " ns" + namespaceCount + ' ' + pkg + ' ' + type.getName() + '.' + name);
443 }
444 namespaceCount++;
445 }
446 }
447 }
448 }
449 catch (RuntimeException e)
450 {
451 logger.debug("setPkgAbbr error in service " + service.getName() + " ns" + namespaceCount + ' ' + pkg + ' ' + type.getName() + ": " + e);
452 }
453 }
454 }
455 }
456 else if (element instanceof AssociationEndFacade)
457 {
458 AssociationEndFacade type = (AssociationEndFacade)element;
459 facade = getType(type);
460 if (facade instanceof AssociationEndFacade)
461 {
462 type = (AssociationEndFacade)facade;
463 }
464 pkg = (PackageFacade) type.getPackage();
465 if (pkg != null && pkg.getFullyQualifiedName().indexOf('.') > 0)
466 {
467 if (facade != null && facade instanceof ClassifierFacade)
468 {
469 ClassifierFacade typeLogic = facade;
470 pkg = (PackageFacade) typeLogic.getPackage();
471 name = typeLogic.getName();
472 if (pkg!=null && pkg.getFullyQualifiedName().indexOf('.') > 0)
473 {
474 if (!pkgSet.contains(pkg))
475 {
476 pkgSet.add(pkg);
477 }
478 if (!packageAbbr.containsKey(pkg))
479 {
480 packageAbbr.put(pkg, "ns" + namespaceCount);
481 if (logger.isDebugEnabled())
482 {
483 logger.debug(service.getName() + " ns" + namespaceCount + ' ' + pkg + ' ' + type.getName());
484 }
485 namespaceCount++;
486 }
487 }
488 }
489 else
490 {
491 if (logger.isDebugEnabled())
492 {
493 logger.debug("setPkgAbbr element association " + pkg + '.' + name);
494 }
495 name = type.getName();
496
497 for (AssociationEndFacade otherEnd : (List<AssociationEndFacade>)type.getType().getNavigableConnectingEnds(follow))
498 {
499 try
500 {
501 ClassifierFacade endType = getType(otherEnd);
502 if (endType != null)
503 {
504 pkg = (PackageFacade) endType.getPackage();
505 name = endType.getName();
506 if (pkg!=null && pkg.getFullyQualifiedName().indexOf('.') > 0)
507 {
508 if (!pkgSet.contains(pkg))
509 {
510 pkgSet.add(pkg);
511 }
512 if (!packageAbbr.containsKey(pkg))
513 {
514 packageAbbr.put(pkg, "ns" + namespaceCount);
515 if (logger.isDebugEnabled())
516 {
517 logger.debug(service.getName() + " ns" + namespaceCount + ' ' + pkg + ' ' + type.getName());
518 }
519 namespaceCount++;
520 }
521 }
522 }
523 }
524 catch (RuntimeException e)
525 {
526 logger.debug("setPkgAbbr error in service " + pkg + '.' + name + " ns" + namespaceCount);
527 }
528 }
529 }
530 }
531 }
532 else if (element instanceof EnumerationFacade)
533 {
534 EnumerationFacade type = (EnumerationFacade)element;
535 if (getType(type) != null)
536 {
537 type = (EnumerationFacade)getType(type);
538 }
539 pkg = (PackageFacade) type.getPackage();
540 if (pkg!=null && pkg.getFullyQualifiedName().indexOf('.') > 0)
541 {
542 if (!pkgSet.contains(pkg))
543 {
544 pkgSet.add(pkg);
545 }
546 if (!packageAbbr.containsKey(pkg))
547 {
548 packageAbbr.put(pkg, "ns" + namespaceCount);
549 if (logger.isDebugEnabled())
550 {
551 logger.debug(service.getName() + " ns" + namespaceCount + ' ' + pkg + ' ' + type.getName() + '.' + name);
552 }
553 namespaceCount++;
554 }
555 }
556 }
557 else if (element.getName().endsWith("[]"))
558 {
559
560 }
561 else
562 {
563
564 logger.error("setPkgAbbr Unexpected element in service " + pkg + '.' + name + " type: " + element);
565 }
566 }
567 return pkgSet;
568 }
569
570
571
572
573
574
575
576
577
578
579 public Collection<PackageFacade> getPackageReferences(WebServiceLogicImpl service, Set<MetafacadeBase> types, String packageName, boolean follow)
580 {
581 Collection<PackageFacade> pkgRef = new TreeSet<PackageFacade>();
582 if (StringUtils.isNotBlank(packageName))
583 {
584 String name = null;
585 PackageFacade pkg = null;
586 String pkgRefs = "";
587 if (types!=null)
588 {
589
590 for (final MetafacadeBase element : types)
591 {
592 ClassifierFacade facade = service.getType(element);
593 if (facade != null)
594 {
595 pkg = (PackageFacade) facade.getPackage();
596 if (logger.isDebugEnabled())
597 {
598 name = facade.getName();
599
600 }
601 if (pkg != null && pkg.getFullyQualifiedName().indexOf('.') > 0 && pkg.getFullyQualifiedName().equals(packageName))
602 {
603
604
605 GeneralizableElementFacade generalization = facade.getGeneralization();
606 if (generalization != null)
607 {
608 pkg = (PackageFacade) generalization.getPackage();
609 if (pkg!=null && !pkg.getFullyQualifiedName().equals(packageName) && !pkgRef.contains(pkg))
610 {
611 pkgRef.add(pkg);
612 if (logger.isDebugEnabled())
613 {
614 pkgRefs += pkg + ",";
615 logger.debug("getPackageReferences packageName=" + packageName + " add facadeAttribute " + pkg + '.' + name);
616 }
617 }
618 }
619 for (ModelElementFacade attr : (List<ModelElementFacade>)facade.getProperties(follow))
620 {
621 try
622 {
623 ClassifierFacade attrType = getType(attr);
624 if (attrType != null)
625 {
626 pkg = (PackageFacade) attrType.getPackage();
627 name = attrType.getName();
628 if (pkg!=null && !pkg.getFullyQualifiedName().equals(packageName) && !pkgRef.contains(pkg) && pkg.getFullyQualifiedName().indexOf('.') > 0)
629 {
630 pkgRef.add(pkg);
631 if (logger.isDebugEnabled())
632 {
633 pkgRefs += pkg + ",";
634 logger.debug("getPackageReferences packageName=" + packageName + " add facadeAttribute " + pkg + '.' + name);
635 }
636 }
637 }
638 }
639 catch (RuntimeException e)
640 {
641 logger.error("getPackageReferences packageName=" + packageName + " add facadeAttribute " + pkg + '.' + name + ": " + e);
642 }
643 }
644 for (final AssociationEndFacade endFacade : (List<AssociationEndFacade>)facade.getNavigableConnectingEnds(follow))
645 {
646 try
647 {
648 if (getType(endFacade) != null)
649 {
650 ClassifierFacade otherEnd = getType(endFacade);
651 pkg = (PackageFacade) otherEnd.getPackage();
652 name = otherEnd.getName();
653 if (pkg!=null && !pkg.getFullyQualifiedName().equals(packageName) && !pkgRef.contains(pkg) && pkg.getFullyQualifiedName().indexOf('.') > 0)
654 {
655 pkgRef.add(pkg);
656 if (logger.isDebugEnabled())
657 {
658 pkgRefs += pkg + ",";
659 logger.debug("getPackageReferences packageName=" + packageName + " add facadeOtherEnd " + pkg + '.' + name);
660 }
661 }
662 }
663 }
664 catch (RuntimeException e)
665 {
666 logger.error("getPackageReferences packageName=" + packageName + " add facadeOtherEnd " + pkg + '.' + name + ": " + e);
667 }
668 }
669 }
670 }
671
672 else if (element instanceof ClassifierFacade)
673 {
674 ClassifierFacade type = (ClassifierFacade)element;
675 if (getType(type) != null)
676 {
677 type = getType(type);
678 }
679 pkg = (PackageFacade) type.getPackage();
680 if (logger.isDebugEnabled())
681 {
682 logger.debug("getPackageReferences packageName=" + packageName + " ClassifierFacade " + pkg + '.' + name);
683 }
684 if (pkg != null && pkg.getFullyQualifiedName().indexOf('.') > 0 && pkg.getFullyQualifiedName().equals(packageName))
685 {
686
687 for (ModelElementFacade attr : (List<ModelElementFacade>)type.getProperties(follow))
688 {
689 try
690 {
691 ClassifierFacade attrType = getType(attr);
692 if (attrType != null)
693 {
694 pkg = (PackageFacade) attr.getPackage();
695 name = attr.getName();
696 }
697 if (pkg!=null && !pkg.getFullyQualifiedName().equals(packageName) && !pkgRef.contains(pkg) && pkg.getFullyQualifiedName().indexOf('.') > 0)
698 {
699 pkgRef.add(pkg);
700 if (logger.isDebugEnabled())
701 {
702 pkgRefs += pkg + ",";
703 logger.debug("getPackageReferences packageName=" + packageName + " add attribute " + pkg + '.' + name);
704 }
705 }
706 }
707 catch (RuntimeException e)
708 {
709 logger.error("getPackageReferences packageName=" + packageName + " add attribute " + pkg + '.' + name + ": " + e);
710 }
711 }
712 for (final Object object : type.getNavigableConnectingEnds(follow))
713 {
714 try
715 {
716 ModelElementFacade endFacade = (ModelElementFacade)object;
717 if (getType(endFacade) != null)
718 {
719 ClassifierFacade otherEnd = getType(endFacade);
720 pkg = (PackageFacade) otherEnd.getPackage();
721 name = otherEnd.getName();
722 if (pkg!=null && !pkg.getFullyQualifiedName().equals(packageName) && !pkgRef.contains(pkg) && pkg.getFullyQualifiedName().indexOf('.') > 0)
723 {
724 pkgRef.add(pkg);
725 if (logger.isDebugEnabled())
726 {
727 pkgRefs += pkg + ",";
728 logger.debug("getPackageReferences packageName=" + packageName + " add otherEnd " + pkg + '.' + name);
729 }
730 }
731 }
732 }
733 catch (RuntimeException e)
734 {
735 logger.error("getPackageReferences packageName=" + packageName + " add otherEnd " + pkg + '.' + name + ": " + e);
736 }
737 }
738 }
739 }
740 else if (element instanceof AssociationEndFacade)
741 {
742 AssociationEndFacade type = (AssociationEndFacade)element;
743 facade = getType(type);
744
745 if (facade instanceof AssociationEndFacade)
746 {
747 type = (AssociationEndFacade)facade;
748 }
749 pkg = (PackageFacade) type.getPackage();
750 if (logger.isDebugEnabled())
751 {
752 logger.debug("getPackageReferences packageName=" + packageName + " AssociationEndFacade " + pkg + '.' + name);
753 }
754 if (pkg != null && pkg.getFullyQualifiedName().indexOf('.') > 0 && pkg.getFullyQualifiedName().equals(packageName))
755 {
756 if (facade != null && facade instanceof ClassifierFacade)
757 {
758 ClassifierFacade typeLogic = facade;
759 pkg = (PackageFacade) typeLogic.getPackage();
760 if (logger.isDebugEnabled())
761 {
762 name = typeLogic.getName();
763 logger.debug("getPackageReferences packageName=" + packageName + " element typeLogic " + pkg + '.' + name);
764 }
765 if (pkg != null && pkg.getFullyQualifiedName().indexOf('.') > 0 && !pkg.getFullyQualifiedName().equals(packageName) && !pkgRef.contains(pkg))
766 {
767 pkgRef.add(pkg);
768 if (logger.isDebugEnabled())
769 {
770 pkgRefs += pkg + ",";
771 logger.debug("getPackageReferences packageName=" + packageName + " add typeLogic " + pkg + '.' + name);
772 }
773 }
774 }
775 else
776 {
777 if (logger.isDebugEnabled())
778 {
779 logger.debug("getPackageReferences packageName=" + packageName + " element association " + pkg + '.' + name);
780 }
781 name = type.getName();
782
783 for (final Object object : type.getType().getNavigableConnectingEnds(follow))
784 {
785 try
786 {
787 ModelElementFacade endFacade = (ModelElementFacade)object;
788 if (getType(endFacade) != null)
789 {
790 ClassifierFacade otherEnd = getType(endFacade);
791 pkg = (PackageFacade) otherEnd.getPackage();
792 name = otherEnd.getName();
793 if (pkg!=null && !pkg.getFullyQualifiedName().equals(packageName) && !pkgRef.contains(pkg) && pkg.getFullyQualifiedName().indexOf('.') > 0)
794 {
795 pkgRef.add(pkg);
796 if (logger.isDebugEnabled())
797 {
798 pkgRefs += pkg + ",";
799 logger.debug("getPackageReferences packageName=" + packageName + " add otherEnd " + pkg + '.' + name);
800 }
801 }
802 }
803 }
804 catch (RuntimeException e)
805 {
806 logger.error("getPackageReferences packageName=" + packageName + " add otherEnd " + pkg + '.' + name + ": " + e);
807 }
808 }
809 }
810 }
811 }
812 else if (element instanceof EnumerationFacade)
813 {
814 EnumerationFacade type = (EnumerationFacade)element;
815 if (getType(type) != null)
816 {
817 type = (EnumerationFacade)getType(type);
818 }
819 pkg = (PackageFacade) type.getPackage();
820 if (pkg != null && pkg.getFullyQualifiedName().indexOf('.') > 0 && pkg.getFullyQualifiedName().equals(packageName))
821 {
822 for (ModelElementFacade attr : (List<ModelElementFacade>)type.getAllProperties())
823 {
824 ClassifierFacade attrType = getType(attr);
825 if (attrType != null)
826 {
827 pkg = (PackageFacade) attr.getPackage();
828 name = attr.getName();
829 }
830 if (!pkg.getFullyQualifiedName().equals(packageName) && !pkgRef.contains(pkg) && pkg.getFullyQualifiedName().indexOf('.') > 0)
831 {
832 pkgRef.add(pkg);
833 if (logger.isDebugEnabled())
834 {
835 pkgRefs += pkg + ",";
836 logger.debug("getPackageReferences packageName=" + packageName + " add enumeration attribute " + pkg + '.' + name);
837 }
838 }
839 }
840 }
841 }
842 else if (element.getValidationName() != null && element.getValidationName().endsWith("[]"))
843 {
844
845 }
846 else
847 {
848
849 logger.error("getPackageReferences Unexpected element type in service " + packageName + '.' + name + " : " + element);
850 }
851 }
852 }
853 if (packageName.equals(service.getPackageName()))
854 {
855
856 for (WebServiceOperation op : service.getAllowedOperations())
857 {
858 for (Object opit : op.getExceptions())
859 {
860 if (opit instanceof ModelElementFacade)
861 {
862 ModelElementFacade arg = (ModelElementFacade)opit;
863 pkg = (PackageFacade) arg.getPackage();
864 name = arg.getName();
865 }
866 else if (opit instanceof PackageFacade)
867 {
868 pkg = (PackageFacade) opit;
869 }
870 else if (opit instanceof WSDLType)
871 {
872 WSDLType type = (WSDLType) opit;
873 if (!type.getAssociationEnds().isEmpty())
874 {
875
876 ClassifierFacade fault = type.getAssociationEnds().get(0).getOtherEnd().getType();
877 pkg = (PackageFacade) fault.getPackage();
878 name = fault.getName();
879 }
880 }
881 else
882 {
883 pkg = null;
884 }
885 if (pkg!=null && !pkg.getFullyQualifiedName().equals(service.getPackageName()) && pkg.getFullyQualifiedName().indexOf('.') > 0 && !pkgRef.contains(pkg))
886 {
887 pkgRef.add(pkg);
888 if (logger.isDebugEnabled())
889 {
890 pkgRefs += pkg + ",";
891 logger.debug("getPackageReferences packageName=" + packageName + " add exception " + pkg + '.' + name);
892 }
893 }
894 }
895 for (final ParameterFacade arg : op.getParameters())
896 {
897 pkg = (PackageFacade) arg.getType().getPackage();
898 name = arg.getType().getName();
899 if (pkg!=null && !pkg.getFullyQualifiedName().equals(service.getPackageName()) && pkg.getFullyQualifiedName().indexOf('.') > 0 && !pkgRef.contains(pkg))
900 {
901 pkgRef.add(pkg);
902 if (logger.isDebugEnabled())
903 {
904 pkgRefs += pkg + ",";
905 logger.debug("getPackageReferences packageName=" + packageName + " add parameter " + pkg + '.' + name);
906 }
907 }
908 }
909 if (op.getReturnType()!=null)
910 {
911 pkg = (PackageFacade) op.getReturnType().getPackage();
912 name = op.getReturnType().getName();
913 if (logger.isDebugEnabled())
914 {
915 logger.debug("getPackageReferences packageName=" + packageName + " return " + pkg + '.' + name);
916 }
917 if (pkg!=null && !pkg.getFullyQualifiedName().equals(service.getPackageName()) && pkg.getFullyQualifiedName().indexOf('.') > 0 && !pkgRef.contains(pkg))
918 {
919 pkgRef.add(pkg);
920 if (logger.isDebugEnabled())
921 {
922 pkgRefs += pkg + ",";
923 logger.debug("getPackageReferences packageName=" + packageName + " add return " + pkg + '.' + name);
924 }
925 }
926 }
927 }
928 }
929 if (logger.isDebugEnabled())
930 {
931 logger.debug("getPackageReferences packageName=" + packageName + ' ' + pkgRefs);
932 }
933 }
934 else
935 {
936 if (logger.isDebugEnabled())
937 {
938 logger.debug("getPackageReferences packageName=null");
939 }
940 }
941 return pkgRef;
942 }
943
944
945
946
947
948
949
950 public Collection<PackageFacade> getExceptionReferences(PackageFacade packageFacade)
951 {
952 Collection<PackageFacade> pkgRef = new TreeSet<PackageFacade>();
953 if (packageFacade != null)
954 {
955 String name = null;
956 PackageFacade pkg = null;
957 String packageName = packageFacade.getFullyQualifiedName();
958 @SuppressWarnings("unused")
959 String pkgRefs = "";
960
961 for (final ClassifierFacade classifier : packageFacade.getClasses())
962 {
963
964 if (classifier != null)
965 {
966 pkg = (PackageFacade) classifier.getPackage();
967 if (classifier.hasStereotype(UMLProfile.STEREOTYPE_WEBSERVICE))
968 {
969
970 for (final OperationFacade op : classifier.getOperations())
971 {
972 for (final ModelElementFacade arg : (Collection<ModelElementFacade>)op.getExceptions())
973 {
974
975 pkg = (PackageFacade) arg.getPackage();
976 if (pkg != null && !pkg.getFullyQualifiedName().equals(classifier.getPackageName()) && pkg.getFullyQualifiedName().indexOf('.') > 0 && !pkgRef.contains(pkg))
977 {
978 pkgRef.add(pkg);
979 if (logger.isDebugEnabled())
980 {
981 pkgRefs += pkg + ",";
982 logger.debug("getPackageReferences packageName=" + packageName + " add parameter " + pkg + '.' + name);
983 }
984 }
985 }
986 }
987 }
988 }
989 }
990 }
991 return pkgRef;
992 }
993
994
995
996
997
998
999
1000
1001 public Collection<PackageFacade> getPackageReferences(PackageFacade packageFacade, boolean follow)
1002 {
1003 Collection<PackageFacade> pkgRef = new TreeSet<PackageFacade>();
1004 if (packageFacade != null)
1005 {
1006 String name = null;
1007 PackageFacade pkg = null;
1008 String packageName = packageFacade.getFullyQualifiedName();
1009 String pkgRefs = "";
1010
1011 for (final ClassifierFacade facade : packageFacade.getClasses())
1012 {
1013
1014 if (facade != null)
1015 {
1016 pkg = (PackageFacade) facade.getPackage();
1017 if (logger.isDebugEnabled())
1018 {
1019 name = facade.getName();
1020 logger.debug("getPackageReferences packageName=" + packageName + " facade " + pkg + '.' + name);
1021 }
1022
1023 GeneralizableElementFacade generalization = facade.getGeneralization();
1024 if (generalization != null)
1025 {
1026 pkg = (PackageFacade) generalization.getPackage();
1027 if (pkg!=null && !pkg.getFullyQualifiedName().equals(packageName) && !pkgRef.contains(pkg))
1028 {
1029 pkgRef.add(pkg);
1030 if (logger.isDebugEnabled())
1031 {
1032 pkgRefs += pkg + ",";
1033 logger.debug("getPackageReferences packageName=" + packageName + " add facadeAttribute " + pkg + '.' + name);
1034 }
1035 }
1036 }
1037 if (facade.hasStereotype("ValueObject") || facade.hasStereotype("Exception") || facade.hasStereotype("UnexpectedException") || facade.hasStereotype("ApplicationException"))
1038 {
1039
1040 for (ModelElementFacade attr : (List<ModelElementFacade>)facade.getProperties(follow))
1041 {
1042 try
1043 {
1044 ClassifierFacade attrType = getType(attr);
1045 if (attrType != null)
1046 {
1047 pkg = (PackageFacade) attrType.getPackage();
1048 name = attrType.getName();
1049 if (pkg!=null && !pkg.getFullyQualifiedName().equals(packageName) && !pkgRef.contains(pkg) && pkg.getFullyQualifiedName().indexOf('.') > 0)
1050 {
1051 pkgRef.add(pkg);
1052 if (logger.isDebugEnabled())
1053 {
1054 pkgRefs += pkg + ",";
1055 logger.debug("getPackageReferences packageName=" + packageName + " add facadeAttribute " + pkg + '.' + name);
1056 }
1057 }
1058 }
1059 }
1060 catch (RuntimeException e)
1061 {
1062 logger.error("getPackageReferences packageName=" + packageName + " add facadeAttribute " + pkg + '.' + name + ": " + e);
1063 }
1064 }
1065 for (final AssociationEndFacade endFacade : (List<AssociationEndFacade>)facade.getNavigableConnectingEnds(follow))
1066 {
1067 try
1068 {
1069 if (getType(endFacade) != null)
1070 {
1071 ClassifierFacade otherEnd = getType(endFacade);
1072 pkg = (PackageFacade) otherEnd.getPackage();
1073 name = otherEnd.getName();
1074 if (pkg!=null && !pkg.getFullyQualifiedName().equals(packageName) && !pkgRef.contains(pkg) && pkg.getFullyQualifiedName().indexOf('.') > 0)
1075 {
1076 pkgRef.add(pkg);
1077 if (logger.isDebugEnabled())
1078 {
1079 pkgRefs += pkg + ",";
1080 logger.debug("getPackageReferences packageName=" + packageName + " add facadeOtherEnd " + pkg + '.' + name);
1081 }
1082 }
1083 }
1084 }
1085 catch (RuntimeException e)
1086 {
1087 logger.error("getPackageReferences packageName=" + packageName + " add facadeOtherEnd " + pkg + '.' + name + ": " + e);
1088 }
1089 }
1090 }
1091 else if (facade.hasStereotype(UMLProfile.STEREOTYPE_WEBSERVICE))
1092 {
1093
1094 for (final OperationFacade op : facade.getOperations())
1095 {
1096 for (final ModelElementFacade arg : (Collection<ModelElementFacade>)op.getExceptions())
1097 {
1098
1099 pkg = (PackageFacade) arg.getPackage();
1100 if (pkg != null && !pkg.getFullyQualifiedName().equals(facade.getPackageName()) && pkg.getFullyQualifiedName().indexOf('.') > 0 && !pkgRef.contains(pkg))
1101 {
1102 pkgRef.add(pkg);
1103 if (logger.isDebugEnabled())
1104 {
1105 pkgRefs += pkg + ",";
1106 logger.debug("getPackageReferences packageName=" + packageName + " add parameter " + pkg + '.' + name);
1107 }
1108 }
1109 }
1110 for (final ParameterFacade arg : op.getParameters())
1111 {
1112 pkg = (PackageFacade) arg.getType().getPackage();
1113 name = arg.getType().getName();
1114 if (pkg!=null && !pkg.getFullyQualifiedName().equals(facade.getPackageName()) && pkg.getFullyQualifiedName().indexOf('.') > 0 && !pkgRef.contains(pkg))
1115 {
1116 pkgRef.add(pkg);
1117 if (logger.isDebugEnabled())
1118 {
1119 pkgRefs += pkg + ",";
1120 logger.debug("getPackageReferences packageName=" + packageName + " add parameter " + pkg + '.' + name);
1121 }
1122 }
1123 }
1124 if (op.getReturnType()!=null)
1125 {
1126 pkg = (PackageFacade) op.getReturnType().getPackage();
1127 name = op.getReturnType().getName();
1128 if (pkg!=null && !pkg.getFullyQualifiedName().equals(facade.getPackageName()) && pkg.getFullyQualifiedName().indexOf('.') > 0 && !pkgRef.contains(pkg))
1129 {
1130 pkgRef.add(pkg);
1131 if (logger.isDebugEnabled())
1132 {
1133 pkgRefs += pkg + ",";
1134 logger.debug("getPackageReferences packageName=" + packageName + " add return " + pkg + '.' + name);
1135 }
1136 }
1137 }
1138 }
1139 }
1140
1141
1142
1143
1144 }
1145 }
1146 if (logger.isDebugEnabled())
1147 {
1148 logger.debug("getPackageReferences packageName=" + packageName + ' ' + pkgRefs);
1149 }
1150 }
1151 else
1152 {
1153 if (logger.isDebugEnabled())
1154 {
1155 logger.debug("getPackageReferences packageName=null");
1156 }
1157 }
1158 return pkgRef;
1159 }
1160
1161
1162
1163
1164
1165
1166 public List<WebServiceOperation> getAllowedOperations(PackageFacade packageFacade)
1167 {
1168 List<WebServiceOperation> operations = new ArrayList<WebServiceOperation>();
1169 for (final ModelElementFacade mefacade : packageFacade.getOwnedElements())
1170 {
1171 if (mefacade != null && mefacade instanceof ClassifierFacade)
1172 {
1173 ClassifierFacade facade = (ClassifierFacade)mefacade;
1174 boolean webService = facade.hasStereotype(UMLProfile.STEREOTYPE_WEBSERVICE);
1175 for (final OperationFacade op : facade.getOperations())
1176 {
1177 boolean visibility = op.getVisibility().equals("public") || op.getVisibility().equals("protected");
1178 if (visibility && (webService || op.hasStereotype(UMLProfile.STEREOTYPE_WEBSERVICE_OPERATION)))
1179 {
1180 operations.add((WebServiceOperation) op);
1181 }
1182 }
1183 }
1184 }
1185
1186 Collections.sort(
1187 operations,
1188 new OperationNameComparator());
1189 return operations;
1190 }
1191
1192
1193
1194
1195
1196
1197 public Collection<ModelElementFacade> getAllowedOperationExceptions(PackageFacade packageFacade)
1198 {
1199 final Collection<ModelElementFacade> exceptions = new HashSet<ModelElementFacade>();
1200
1201
1202 for (final OperationFacade operation : this.getAllowedOperations(packageFacade))
1203 {
1204 exceptions.addAll(operation.getExceptions());
1205 }
1206
1207 return exceptions;
1208 }
1209
1210
1211
1212
1213
1214
1215
1216
1217 public Collection<ModelElementFacade> getPackageTypes(PackageFacade packageFacade, boolean follow)
1218 {
1219 Collection<ModelElementFacade> pkgTypes = new HashSet<ModelElementFacade>();
1220 if (packageFacade != null)
1221 {
1222 String name = null;
1223 String pkg = null;
1224 String packageName = packageFacade.getFullyQualifiedName();
1225 String pkgRefs = "";
1226
1227
1228 for (final ModelElementFacade mefacade : packageFacade.getOwnedElements())
1229 {
1230 if (logger.isDebugEnabled())
1231 {
1232 logger.debug("getPackageTypes packageName=" + packageName + " element " + mefacade);
1233 }
1234 if (mefacade != null && mefacade instanceof ClassifierFacade)
1235 {
1236 ClassifierFacade facade = (ClassifierFacade)mefacade;
1237 if (logger.isDebugEnabled())
1238 {
1239 name = facade.getName();
1240 logger.debug("getPackageTypes packageName=" + packageName + " facade " + name);
1241 }
1242 if (facade.hasStereotype("ValueObject"))
1243 {
1244 if (!pkgTypes.contains(facade))
1245 {
1246 pkgTypes.add(facade);
1247 if (logger.isDebugEnabled())
1248 {
1249 name = facade.getName();
1250 pkgRefs += name + ',';
1251 logger.debug("getPackageTypes packageName=" + packageName + " add facadeValueObject " + name);
1252 }
1253 }
1254 }
1255 else if (facade.isEnumeration() || facade.hasStereotype("Enumeration"))
1256 {
1257 if (!pkgTypes.contains(facade))
1258 {
1259 pkgTypes.add(facade);
1260 if (logger.isDebugEnabled())
1261 {
1262 name = facade.getName();
1263 pkgRefs += name + ',';
1264 logger.debug("getPackageTypes packageName=" + packageName + " add facadeEnumeration " + name);
1265 }
1266 }
1267 }
1268 else if (facade.hasStereotype("Exception") || facade.hasStereotype("ApplicationException")
1269 || facade.hasStereotype("UnexpectedException") || facade.hasStereotype("WebFault"))
1270 {
1271 if (!pkgTypes.contains(facade))
1272 {
1273 pkgTypes.add(facade);
1274 if (logger.isDebugEnabled())
1275 {
1276 name = facade.getName();
1277 pkgRefs += name + ',';
1278 logger.debug("getPackageTypes packageName=" + packageName + " add facadeEnumeration " + name);
1279 }
1280 }
1281 }
1282 else if (facade.hasStereotype(UMLProfile.STEREOTYPE_WEBSERVICE))
1283 {
1284
1285 for (final OperationFacade op : facade.getOperations())
1286 {
1287 for (final ModelElementFacade arg : (Collection<ModelElementFacade>)op.getExceptions())
1288 {
1289 pkg = arg.getPackageName();
1290 if (pkg!=null && pkg.equals(facade.getPackageName()) && pkg.indexOf('.') > 0 && !pkgTypes.contains(arg))
1291 {
1292 pkgTypes.add(arg);
1293 if (logger.isDebugEnabled())
1294 {
1295 name = arg.getName();
1296 pkgRefs += name + ',';
1297 logger.debug("getPackageTypes packageName=" + packageName + " add exception " + pkg + '.' + name);
1298 }
1299 }
1300 }
1301 for (final ParameterFacade arg : op.getParameters())
1302 {
1303 pkg = arg.getType().getPackageName();
1304 name = arg.getType().getName();
1305
1306
1307 if (pkg!=null && pkg.equals(facade.getPackageName()) && pkg.indexOf('.') > 0 && !pkgTypes.contains(arg.getType()))
1308 {
1309 pkgTypes.add(arg.getType());
1310 if (logger.isDebugEnabled())
1311 {
1312 name = arg.getName();
1313 pkgRefs += name + ',';
1314 logger.debug("getPackageTypes packageName=" + packageName + " add parameter " + pkg + '.' + name);
1315 }
1316 }
1317 }
1318 if (op.getReturnType()!=null)
1319 {
1320 pkg = op.getReturnType().getPackageName();
1321 if (logger.isDebugEnabled())
1322 {
1323 name = op.getReturnType().getName();
1324 logger.debug("getPackageTypes packageName=" + packageName + " return " + pkg + '.' + name);
1325 }
1326 if (pkg!=null && pkg.equals(facade.getPackageName()) && pkg.indexOf('.') > 0 && !pkgTypes.contains(op.getReturnType()))
1327 {
1328 pkgTypes.add(op.getReturnType());
1329 if (logger.isDebugEnabled())
1330 {
1331 pkgRefs += name + ',';
1332 logger.debug("getPackageTypes packageName=" + packageName + " add return " + pkg + '.' + name);
1333 }
1334 }
1335 }
1336 }
1337 }
1338 }
1339 }
1340 if (logger.isDebugEnabled())
1341 {
1342 logger.debug("getPackageTypes packageName=" + packageName + ' ' + pkgRefs);
1343 }
1344 }
1345 else
1346 {
1347 if (logger.isDebugEnabled())
1348 {
1349 logger.debug("getPackageTypes packageName=null");
1350 }
1351 }
1352 return pkgTypes;
1353 }
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364 public Collection<ModelElementFacade> getPackageTypes(WebServiceLogicImpl service, Set<MetafacadeBase> types, String packageName, boolean follow)
1365 {
1366 Collection<ModelElementFacade> pkgTypes = new TreeSet<ModelElementFacade>(service.new TypeComparator());
1367 if (StringUtils.isNotBlank(packageName))
1368 {
1369 String name = null;
1370 String pkg = null;
1371 String pkgRefs = "";
1372
1373 for (final MetafacadeBase element : types)
1374 {
1375
1376 ClassifierFacade facade = service.getType(element);
1377 if (facade != null)
1378 {
1379 pkg = facade.getPackageName();
1380 if (logger.isDebugEnabled())
1381 {
1382 name = facade.getName();
1383 logger.debug("getPackageTypes packageName=" + packageName + " facade " + pkg + '.' + name);
1384 }
1385 if (pkg != null && pkg.indexOf('.') > 0 && pkg.equals(packageName) && !pkgTypes.contains(facade))
1386 {
1387 pkgTypes.add(facade);
1388 if (logger.isDebugEnabled())
1389 {
1390 pkgRefs += facade.getName() + ',';
1391 logger.debug("getPackageTypes packageName=" + packageName + " add facade " + facade.getPackageName() + '.' + facade.getName());
1392 }
1393 }
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406 }
1407
1408 if (element instanceof ClassifierFacade)
1409 {
1410 ClassifierFacade type = (ClassifierFacade)element;
1411 facade = getType(type);
1412 if (facade != null)
1413 {
1414 if (facade instanceof ClassifierFacade)
1415 {
1416 type = getType(type);
1417 }
1418 }
1419 pkg = type.getPackageName();
1420 if (logger.isDebugEnabled())
1421 {
1422 name = type.getName();
1423 logger.debug("getPackageTypes packageName=" + packageName + " elementTypeLogic " + pkg + '.' + name);
1424 }
1425 if (pkg != null)
1426 {
1427 if (pkg.indexOf('.') > 0 && pkg.equals(packageName) && !pkgTypes.contains(type))
1428 {
1429 pkgTypes.add(type);
1430 if (logger.isDebugEnabled())
1431 {
1432 pkgRefs += type.getName() + ',';
1433 logger.debug("getPackageTypes packageName=" + packageName + " add typeLogic " + type.getPackageName() + '.' + type.getName());
1434 }
1435 }
1436 if (logger.isDebugEnabled())
1437 {
1438 logger.debug("ClassifierFacade pkg=" + packageName + " refPkg=" + pkg + " name=" + type.getName());
1439 }
1440
1441 for (ModelElementFacade attr : (List<ModelElementFacade>)type.getProperties(follow))
1442 {
1443 try
1444 {
1445 ClassifierFacade attrType = getType(attr);
1446 if (attrType != null)
1447 {
1448 pkg = attrType.getPackageName();
1449 if (pkg!=null && pkg.equals(packageName) && pkg.indexOf('.') > 0 && !pkgTypes.contains(attrType))
1450 {
1451 pkgTypes.add(attrType);
1452 if (logger.isDebugEnabled())
1453 {
1454 name = attrType.getName();
1455 pkgRefs += attrType.getName() + ',';
1456 logger.debug("getPackageTypes packageName=" + packageName + " add attr " + attrType.getPackageName() + '.' + attrType.getName());
1457 }
1458 }
1459 }
1460 }
1461 catch (RuntimeException e)
1462 {
1463 logger.error("getPackageTypes packageName=" + packageName + " add attr " + pkg + '.' + name + ": " + e);
1464 }
1465 }
1466 }
1467 }
1468 else if (element instanceof AssociationEndFacade)
1469 {
1470 AssociationEndFacade type = (AssociationEndFacade)element;
1471 facade = getType(type);
1472
1473 if (facade instanceof AssociationEndFacade)
1474 {
1475 type = (AssociationEndFacade)facade;
1476 }
1477 if (facade != null && facade instanceof ClassifierFacade)
1478 {
1479 ClassifierFacade typeLogic = facade;
1480 pkg = typeLogic.getPackageName();
1481 if (pkg != null && pkg.indexOf('.') > 0 && pkg.equals(packageName) && !pkgTypes.contains(typeLogic))
1482 {
1483 pkgTypes.add(typeLogic);
1484 if (logger.isDebugEnabled())
1485 {
1486 name = typeLogic.getName();
1487 pkgRefs += typeLogic.getName() + ',';
1488 logger.debug("getPackageTypes packageName=" + packageName + " add typeLogic " + type.getPackageName() + '.' + type.getName());
1489 }
1490 }
1491 }
1492 else
1493 {
1494 pkg = type.getPackageName();
1495 if (logger.isDebugEnabled())
1496 {
1497 name = type.getName();
1498 logger.debug("getPackageTypes packageName=" + packageName + " associationEnd " + pkg + '.' + name);
1499 }
1500 if (pkg != null)
1501 {
1502 if (pkg.indexOf('.') > 0 && pkg.equals(packageName) && !pkgTypes.contains(type))
1503 {
1504 pkgTypes.add(type);
1505 if (logger.isDebugEnabled())
1506 {
1507 pkgRefs += type.getName() + ',';
1508 logger.debug("getPackageTypes packageName=" + packageName + " add typeAssoc " + type.getPackageName() + '.' + type.getName());
1509 }
1510 }
1511
1512 try
1513 {
1514 AssociationEndFacade otherEnd = (type.getOtherEnd());
1515 ClassifierFacade endType = getType(otherEnd);
1516 if (endType != null)
1517 {
1518 pkg = endType.getPackageName();
1519 if (logger.isDebugEnabled())
1520 {
1521 name = endType.getName();
1522 logger.debug("getPackageTypes packageName=" + packageName + " otherEnd " + pkg + '.' + name);
1523 }
1524 if (pkg!=null && pkg.equals(packageName) && pkg.indexOf('.') > 0 && !pkgTypes.contains(endType))
1525 {
1526 pkgTypes.add(endType);
1527 if (logger.isDebugEnabled())
1528 {
1529 pkgRefs += endType.getName() + ',';
1530 logger.debug("getPackageTypes packageName=" + packageName + " add otherEnd " + endType.getPackageName() + '.' + otherEnd.getName());
1531 }
1532 }
1533 }
1534 }
1535 catch (RuntimeException e)
1536 {
1537 logger.error("getPackageTypes packageName=" + packageName + " add otherEnd " + pkg + '.' + name + ": " + e);
1538 }
1539
1540 for (final Object object : type.getType().getNavigableConnectingEnds(follow))
1541 {
1542 ClassifierFacade otherEnd = null;
1543 try
1544 {
1545 AssociationEndFacade endFacade = (AssociationEndFacade)object;
1546 if (getType(endFacade) != null)
1547 {
1548 otherEnd = getType(endFacade);
1549 pkg = otherEnd.getPackageName();
1550 if (logger.isDebugEnabled())
1551 {
1552 name = otherEnd.getName();
1553 logger.debug("getPackageTypes packageName=" + packageName + " NavOtherEnd " + otherEnd.getPackageName() + '.' + otherEnd.getName());
1554 }
1555 if (pkg!=null && pkg.equals(packageName) && pkg.indexOf('.') > 0 && !pkgTypes.contains(otherEnd))
1556 {
1557 pkgTypes.add(otherEnd);
1558 if (logger.isDebugEnabled())
1559 {
1560 pkgRefs += otherEnd.getName() + ',';
1561 logger.debug("getPackageTypes packageName=" + packageName + " add NavOtherEnd " + otherEnd.getPackageName() + '.' + otherEnd.getName());
1562 }
1563 }
1564 }
1565 }
1566 catch (RuntimeException e)
1567 {
1568 if (otherEnd!=null)
1569 {
1570 logger.error("getPackageTypes packageName=" + packageName + " add NavOtherEnd " + otherEnd.getPackageName() + '.' + otherEnd.getName() + ": " + e);
1571 }
1572 else
1573 {
1574 logger.error("getPackageTypes packageName=" + packageName + " add NavOtherEnd " + type.getType().getPackageName() + '.' + type.getType().getName() + ": " + e);
1575 }
1576 }
1577 }
1578 }
1579 }
1580 }
1581 else if (element instanceof EnumerationFacade)
1582 {
1583 EnumerationFacade type = (EnumerationFacade)element;
1584 if (getType(type) != null)
1585 {
1586 type = (EnumerationFacade)getType(type);
1587 }
1588 pkg = type.getPackageName();
1589 if (pkg!=null && pkg.equals(packageName) && pkg.indexOf('.') > 0 && !pkgTypes.contains(type))
1590 {
1591 pkgTypes.add(type);
1592 if (logger.isDebugEnabled())
1593 {
1594 pkgRefs += type.getName() + ',';
1595 logger.debug("getPackageTypes packageName=" + packageName + " add NavOtherEnd " + type.getPackageName() + '.' + type.getName());
1596 }
1597 }
1598 }
1599 else if (facade != null && facade.getName().endsWith("[]"))
1600 {
1601
1602 }
1603 else
1604 {
1605
1606 logger.error("getPackageTypes Unexpected element in service " + pkg + '.' + element + " type: " + facade);
1607 }
1608 }
1609
1610 for (final WebServiceOperation op : service.getAllowedOperations())
1611 {
1612 for (final ModelElementFacade arg : (Collection<ModelElementFacade>)op.getExceptions())
1613 {
1614 pkg = arg.getPackageName();
1615 if (pkg!=null && pkg.equals(packageName) && pkg.indexOf('.') > 0 && !pkgTypes.contains(arg))
1616 {
1617 pkgTypes.add(arg);
1618 if (logger.isDebugEnabled())
1619 {
1620 name = arg.getName();
1621 pkgRefs += arg.getName() + ',';
1622 logger.debug("getPackageTypes packageName=" + packageName + " add service exception " + arg.getPackageName() + '.' + arg.getName());
1623 }
1624 }
1625 }
1626 for (final ParameterFacade arg : op.getParameters())
1627 {
1628 pkg = arg.getType().getPackageName();
1629 if (pkg!=null && pkg.equals(packageName) && pkg.indexOf('.') > 0 && !pkgTypes.contains(arg.getType()))
1630 {
1631 pkgTypes.add(arg.getType());
1632 if (logger.isDebugEnabled())
1633 {
1634 name = arg.getName();
1635 pkgRefs += arg.getName() + ',';
1636 logger.debug("getPackageTypes packageName=" + packageName + " add service parameter " + arg.getPackageName() + '.' + arg.getName());
1637 }
1638 }
1639 }
1640 if (op.getReturnType()!=null)
1641 {
1642 pkg = op.getReturnType().getPackageName();
1643 if (pkg!=null && pkg.equals(packageName) && pkg.indexOf('.') > 0 && !pkgTypes.contains(op.getReturnType()))
1644 {
1645 pkgTypes.add(op.getReturnType());
1646 if (logger.isDebugEnabled())
1647 {
1648 name = op.getReturnType().getName();
1649 pkgRefs += op.getReturnType().getName() + ',';
1650 logger.debug("getPackageTypes packageName=" + packageName + " add service returnType " + op.getReturnType().getPackageName() + '.' + op.getReturnType().getName());
1651 }
1652 }
1653 }
1654 }
1655 if (logger.isDebugEnabled())
1656 {
1657 logger.debug("getPackageTypes packageName=" + packageName + ' ' + pkgRefs);
1658 }
1659 }
1660 else
1661 {
1662 if (logger.isDebugEnabled())
1663 {
1664 logger.debug("getPackageTypes packageName=null");
1665 }
1666 }
1667 return pkgTypes;
1668 }
1669
1670
1671
1672
1673
1674
1675
1676
1677 private ClassifierFacade getType(Object modelElement)
1678 {
1679 try
1680 {
1681 final Introspector introspector = Introspector.instance();
1682 ClassifierFacade type = null;
1683 String typeProperty = "type";
1684
1685
1686 if (introspector.isReadable(modelElement, typeProperty))
1687 {
1688 type = (ClassifierFacade)introspector.getProperty(modelElement, typeProperty);
1689 }
1690
1691
1692 typeProperty = "returnType";
1693 if (type == null && introspector.isReadable(modelElement, typeProperty))
1694 {
1695 type = (ClassifierFacade)introspector.getProperty(modelElement, typeProperty);
1696 }
1697 return type;
1698 }
1699 catch (final Throwable throwable)
1700 {
1701 String errMsg = "Error performing WebServiceLogicImpl.getType";
1702 logger.error(errMsg, throwable);
1703 throw new MetafacadeException(errMsg, throwable);
1704 }
1705 }
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716 public boolean hasComplexTypes(ClassifierFacade facade, boolean follow)
1717 {
1718 boolean rtn = false;
1719
1720 if (!facade.getNavigableConnectingEnds(follow).isEmpty())
1721 {
1722 return true;
1723 }
1724
1725 for (final Object obj : facade.getAttributes(follow))
1726 {
1727 AttributeFacade attr = (AttributeFacade)obj;
1728 if (attr.getUpper() > 1 || attr.getUpper() == -1)
1729 {
1730 return true;
1731 }
1732
1733 String pkg = attr.getType().getFullyQualifiedName(false);
1734 if (logger.isDebugEnabled())
1735 {
1736 String fqn = attr.getGetterSetterTypeName();
1737 String cpkg= attr.getType().getPackageName();
1738 logger.debug("attr=" + attr.getName() + " pkg=" + pkg + " fqn=" + fqn + " cpkg=" + cpkg);
1739 }
1740 if (StringUtils.isEmpty(pkg) || pkg.indexOf('.')<1)
1741 {
1742
1743
1744 }
1745 else if (pkg.length()<9)
1746 {
1747
1748 return true;
1749 }
1750 else
1751 {
1752 pkg=pkg.substring(0, 9);
1753 if (!"java.lang".equals(pkg) && !"java.util".equals(pkg) && !"java.math".equals(pkg))
1754 {
1755 return true;
1756 }
1757 }
1758 }
1759 return rtn;
1760 }
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772 public static String getPackageName(String namespace)
1773 {
1774 if (StringUtils.isBlank(namespace))
1775 {
1776 return "";
1777 }
1778 if (namespace.startsWith("http://"))
1779 {
1780 namespace = namespace.substring(7);
1781 }
1782 if (namespace.endsWith("/"))
1783 {
1784 namespace = namespace.substring(0, namespace.length()-1);
1785 }
1786 if (namespace.endsWith(".xsd"))
1787 {
1788 namespace = namespace.substring(0, namespace.length()-4);
1789 }
1790 String hostname = namespace;
1791 if (namespace.indexOf('/')>0)
1792 {
1793 hostname = namespace.substring(0, namespace.indexOf('/'));
1794 namespace = StringUtils.reverseDelimited(hostname, WebServiceGlobals.NAMESPACE_DELIMITER)
1795 + namespace.substring(namespace.indexOf('/'), namespace.length());
1796 }
1797 else
1798 {
1799 namespace = StringUtils.reverseDelimited(hostname, WebServiceGlobals.NAMESPACE_DELIMITER);
1800 }
1801
1802
1803
1804
1805
1806
1807 namespace = StringUtils.replaceChars(namespace, '-', '_');
1808 namespace = StringUtils.replace(namespace, ".0", "_0");
1809 namespace = StringUtils.replace(namespace, ".1", "_1");
1810 namespace = StringUtils.replace(namespace, ".2", "_2");
1811 namespace = StringUtils.replace(namespace, ".3", "_3");
1812 namespace = StringUtils.replace(namespace, ".4", "_4");
1813 namespace = StringUtils.replace(namespace, ".5", "_5");
1814 namespace = StringUtils.replace(namespace, ".6", "_6");
1815 namespace = StringUtils.replace(namespace, ".7", "_7");
1816 namespace = StringUtils.replace(namespace, ".8", "_8");
1817 namespace = StringUtils.replace(namespace, ".9", "_9");
1818 namespace = StringUtils.replace(namespace, "$", "");
1819 namespace = StringUtils.replaceChars(namespace, '/', WebServiceGlobals.NAMESPACE_DELIMITER);
1820 namespace = StringUtils.replace(namespace, ".0", "._0");
1821 namespace = StringUtils.replace(namespace, ".1", "._1");
1822 namespace = StringUtils.replace(namespace, ".2", "._2");
1823 namespace = StringUtils.replace(namespace, ".3", "._3");
1824 namespace = StringUtils.replace(namespace, ".4", "._4");
1825 namespace = StringUtils.replace(namespace, ".5", "._5");
1826 namespace = StringUtils.replace(namespace, ".6", "._6");
1827 namespace = StringUtils.replace(namespace, ".7", "._7");
1828 namespace = StringUtils.replace(namespace, ".8", "._8");
1829 namespace = StringUtils.replace(namespace, ".9", "._9");
1830 return namespace;
1831 }
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841 public String getElementClassName(String elementName, String namespace)
1842 {
1843 if (StringUtils.isBlank(elementName) || StringUtils.isBlank(namespace))
1844 {
1845 return "";
1846 }
1847 return WebServiceUtils.reversePackage(namespace) + '.' + elementName;
1848 }
1849
1850
1851
1852
1853
1854
1855 public String createConstructor(ModelElementFacade facade)
1856 {
1857 return createConstructor(facade, false);
1858 }
1859
1860
1861
1862
1863
1864
1865
1866 public String createConstructor(ModelElementFacade facade, boolean useMany)
1867 {
1868 return createConstructor(facade, useMany, null);
1869 }
1870
1871
1872
1873
1874
1875
1876
1877
1878 @SuppressWarnings("null")
1879 public String createConstructor(ModelElementFacade facade, boolean useMany, ModelElementFacade parent)
1880 {
1881 if (facade==null)
1882 {
1883 return "facade was null";
1884 }
1885 String rtn = "";
1886 String toString = "";
1887 ClassifierFacade type = null;
1888 String typeName = facade.getFullyQualifiedName();
1889 String name = facade.getName();
1890 String defaultValue = "";
1891
1892 String collectionType = "java.util.ArrayList";
1893 Boolean isMany = null;
1894 boolean isEnumeration = false;
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908 try {
1909 if (logger.isDebugEnabled())
1910 {
1911 logger.debug("facade=" + facade + " parent=" + parent + " useMany=" + useMany);
1912 }
1913 if (facade instanceof ClassifierFacade)
1914 {
1915 ClassifierFacade classifier = (ClassifierFacade) facade;
1916 type = classifier;
1917 typeName = classifier.getFullyQualifiedName();
1918 }
1919 if (facade instanceof AttributeFacade)
1920 {
1921 AttributeFacade attr = (AttributeFacade) facade;
1922 defaultValue = attr.getDefaultValue();
1923 type = attr.getType();
1924 if (useMany)
1925 {
1926 typeName = attr.getGetterSetterTypeName();
1927 }
1928 else
1929 {
1930 typeName = type.getFullyQualifiedName();
1931 }
1932 if (attr.getUpper()>1 || attr.getUpper()==-1)
1933 {
1934 isMany = true;
1935 }
1936 }
1937 else if (facade instanceof WSDLTypeAttributeLogic)
1938 {
1939 WSDLTypeAttributeLogic attr = (WSDLTypeAttributeLogic) facade;
1940 defaultValue = attr.getDefaultValue();
1941 type = attr.getType();
1942 if (useMany)
1943 {
1944 typeName = attr.getGetterSetterTypeName();
1945 }
1946 else
1947 {
1948 typeName = type.getFullyQualifiedName();
1949 }
1950 if (attr.getUpper()>1 || attr.getUpper()==-1)
1951 {
1952 isMany = true;
1953 }
1954 }
1955 else if (facade instanceof ParameterFacade)
1956 {
1957 ParameterFacade attr = (ParameterFacade) facade;
1958 defaultValue = attr.getDefaultValue();
1959 type = attr.getType();
1960 typeName = type.getFullyQualifiedName();
1961 if (type.isEnumeration())
1962 {
1963 facade = type;
1964 }
1965 else if (useMany)
1966 {
1967 typeName = collectionType + '<' + type.getFullyQualifiedName() + '>';
1968 }
1969 else
1970 {
1971 typeName = type.getFullyQualifiedName();
1972 }
1973 if (attr.getUpper()>1 || attr.getUpper()==-1)
1974 {
1975 isMany = true;
1976 }
1977 }
1978 if (facade instanceof AssociationEndFacade)
1979 {
1980 AssociationEndFacade attr = (AssociationEndFacade) facade;
1981 type = attr.getType();
1982 if (useMany)
1983 {
1984 typeName = attr.getGetterSetterTypeName();
1985 }
1986 else
1987 {
1988 typeName = type.getFullyQualifiedName();
1989 }
1990 if (attr.getUpper()>1 || attr.getUpper()==-1)
1991 {
1992 isMany = true;
1993 }
1994 facade = attr.getType();
1995 }
1996 if (facade instanceof WSDLTypeAssociationEnd)
1997 {
1998 WSDLTypeAssociationEnd attr = (WSDLTypeAssociationEnd) facade;
1999 type = attr.getType();
2000 if (useMany)
2001 {
2002 typeName = attr.getGetterSetterTypeName();
2003 }
2004 else
2005 {
2006 typeName = type.getFullyQualifiedName();
2007 }
2008 if (attr.getUpper()>1 || attr.getUpper()==-1)
2009 {
2010 isMany = true;
2011 }
2012 facade = attr.getType();
2013 }
2014
2015 if (parent != null && StringUtils.isEmpty(defaultValue) && ("String".equals(typeName) || "java.lang.String".equals(typeName)))
2016 {
2017
2018 for (final DependencyFacade dependency : parent.getSourceDependencies())
2019 {
2020 if (dependency.getName().equals(facade.getName()))
2021 {
2022 facade = dependency.getTargetElement();
2023
2024
2025 if (facade instanceof WSDLTypeLogic)
2026 {
2027 WSDLTypeLogic wsdlType = (WSDLTypeLogic) facade;
2028 if (logger.isDebugEnabled())
2029 {
2030 logger.debug(wsdlType + " fqn=" + wsdlType.getFullyQualifiedName() + " name="
2031 + wsdlType.getName() + " id=" + wsdlType.getId() + " properties="
2032 + wsdlType.getAllProperties() + " MetaObject=" + wsdlType.getMetaObject() + " properties="
2033 + wsdlType.getProperties());
2034 }
2035 if (StringUtils.isEmpty(wsdlType.getName()))
2036 {
2037 break;
2038 }
2039 }
2040 if (facade instanceof ClassifierFacade)
2041 {
2042 type = (ClassifierFacade) facade;
2043 }
2044 typeName = facade.getFullyQualifiedName();
2045 toString = ".toString()";
2046 if (logger.isDebugEnabled())
2047 {
2048 logger.debug(parent + " " + facade + " = "
2049 + dependency + " type=" + type + " typeName="
2050 + typeName);
2051 }
2052 break;
2053 }
2054 }
2055 }
2056 if (type instanceof WSDLEnumerationTypeLogic)
2057 {
2058 if (logger.isDebugEnabled())
2059 {
2060 logger.debug("facade=" + facade + " type=" + type + " default=" + defaultValue);
2061 }
2062 WSDLEnumerationTypeLogic enumer = (WSDLEnumerationTypeLogic) type;
2063
2064 Collection<AttributeFacade> literals = enumer.getLiterals();
2065 if (StringUtils.isEmpty(defaultValue) && !literals.isEmpty())
2066 {
2067
2068 Object literal = literals.iterator().next();
2069 if (literal instanceof EnumerationLiteralFacade)
2070 {
2071 EnumerationLiteralFacade enumLiteral = (EnumerationLiteralFacade) literal;
2072
2073 Boolean useEnumValueInXSD = Boolean.valueOf(String.valueOf(enumer.getConfiguredProperty("useEnumValueInXSD")));
2074 if (useEnumValueInXSD)
2075 {
2076 defaultValue = enumLiteral.getValue();
2077 }
2078 else
2079 {
2080 defaultValue = enumLiteral.getName();
2081 }
2082 }
2083 else if (literal instanceof AttributeFacade)
2084 {
2085 AttributeFacade attrib = (AttributeFacade) literal;
2086 defaultValue = attrib.getEnumerationValue();
2087 if (defaultValue==null)
2088 {
2089 defaultValue = attrib.getDefaultValue();
2090 }
2091 }
2092
2093
2094 defaultValue = StringUtils.remove(defaultValue, "\"");
2095 defaultValue = enumer.getFullyQualifiedName() + ".fromValue(\"" + defaultValue + "\")";
2096 }
2097 else
2098 {
2099 defaultValue = enumer.getName() + '.' + defaultValue;
2100 }
2101 isEnumeration = true;
2102 }
2103 if (useMany && (isMany==null || isMany.booleanValue()))
2104 {
2105 if (!typeName.startsWith("java.util"))
2106 {
2107 rtn = "new " + collectionType + '<' + typeName + ">()";
2108 }
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121 else
2122 {
2123
2124 rtn = "new " + typeName + "()";
2125 }
2126 }
2127 else if ("String".equals(typeName) || "java.lang.String".equals(typeName))
2128 {
2129 rtn = (StringUtils.isNotBlank(defaultValue) ? defaultValue : '\"' + name + '\"');
2130 }
2131 else if ("Boolean".equals(typeName) || "java.lang.Boolean".equals(typeName))
2132 {
2133 rtn = (StringUtils.isNotBlank(defaultValue) ? "Boolean." + defaultValue.toUpperCase() : "Boolean.TRUE");
2134 }
2135 else if ("boolean".equals(typeName))
2136 {
2137 rtn = (StringUtils.isNotBlank(defaultValue) ? defaultValue : "true");
2138 }
2139 else if ("int".equals(typeName) || "short".equals(typeName) || "long".equals(typeName)
2140 || "byte".equals(typeName) || "float".equals(typeName) || "double".equals(typeName))
2141 {
2142 rtn = (StringUtils.isNotBlank(defaultValue) ? defaultValue : "1");
2143 }
2144 else if ("java.util.Date".equals(typeName))
2145 {
2146 rtn = "new " + typeName + "()";
2147 }
2148 else if ("java.sql.Timestamp".equals(typeName))
2149 {
2150 rtn = "new java.sql.Timestamp(System.currentTimeMillis())";
2151 }
2152 else if ("java.util.Calendar".equals(typeName))
2153 {
2154 rtn = "java.util.Calendar.getInstance()";
2155 }
2156 else if ("org.joda.time.LocalTime".equals(typeName))
2157 {
2158 rtn = "new org.joda.time.LocalTime(1, 1)";
2159 }
2160 else if ("char".equals(typeName))
2161 {
2162 rtn = "'" + (StringUtils.isNotEmpty(defaultValue) ? defaultValue : name.substring(0, 1)) + "'";
2163 }
2164 else if ("Character".equals(typeName))
2165 {
2166 rtn = "new Character('" + (StringUtils.isNotEmpty(defaultValue) ? "new Character(" + defaultValue : name.substring(0, 1)) + "')";
2167 }
2168 else if ("Byte".equals(typeName) || "java.lang.Byte".equals(typeName))
2169 {
2170 rtn = "new Byte(\"" + facade.getName() + "\")";
2171 }
2172 else if ("Short".equals(typeName) || "java.lang.Short".equals(typeName)
2173 || "Integer".equals(typeName) || "java.lang.Integer".equals(typeName)
2174 || "Long".equals(typeName) || "java.lang.Long".equals(typeName)
2175 || "Float".equals(typeName) || "java.lang.Float".equals(typeName)
2176 || "Double".equals(typeName) || "java.lang.Double".equals(typeName)
2177 || "java.math.BigDecimal".equals(typeName))
2178 {
2179 rtn = (!StringUtils.isEmpty(defaultValue) ? typeName + ".valueOf(" + defaultValue + ")" : typeName + ".valueOf(1)");
2180 }
2181 else if ("java.math.BigInteger".equals(typeName))
2182 {
2183 rtn = (!StringUtils.isEmpty(defaultValue) ? "java.math.BigInteger.valueOf(" + defaultValue + ')' : "java.math.BigInteger.valueOf(1)");
2184 }
2185 else if ("byte[]".equals(typeName))
2186 {
2187 rtn = (StringUtils.isNotBlank(defaultValue) ? defaultValue : '\"' + name + '\"') + ".getBytes()";
2188 }
2189 else if ("char[]".equals(typeName))
2190 {
2191 String value = StringUtils.isNotBlank(defaultValue) ? defaultValue : name;
2192 if (!value.startsWith("\""))
2193 {
2194 value = "\"" + value;
2195 }
2196 if (!value.endsWith("\""))
2197 {
2198 value = value + "\"";
2199 }
2200 rtn = value + ".toCharArray()";
2201 }
2202 else if ("String[]".equals(typeName))
2203 {
2204 rtn = "new String[] { " + (StringUtils.isNotBlank(defaultValue) ? defaultValue : '\"' + name + '\"') + " }";
2205 }
2206 else if (isEnumeration)
2207 {
2208 if (useMany)
2209 {
2210 rtn = collectionType + '<' + defaultValue + '>';
2211 }
2212 else
2213 {
2214 rtn = defaultValue;
2215 }
2216 }
2217 else if (!StringUtils.isEmpty(defaultValue))
2218 {
2219 rtn = "new " + typeName + '(' + defaultValue + ')';
2220 }
2221 else if (type != null && type.hasStereotype("Entity"))
2222 {
2223
2224 rtn = '(' + typeName + ")new " + typeName + "Impl()";
2225 }
2226 else if (type instanceof GeneralizableElementFacade)
2227 {
2228
2229 if (typeName.endsWith("[]"))
2230 {
2231 rtn = "{ new " + typeName.substring(0, typeName.length()-2) + "() }";
2232 }
2233 else
2234 {
2235 rtn = "new " + typeName + "()";
2236 }
2237
2238
2239
2240
2241 if (type.isAbstract())
2242 {
2243
2244 for (GeneralizableElementFacade spec : type.getSpecializations())
2245 {
2246 if (spec.getName().equals(type.getName() + "Impl"))
2247 {
2248 rtn = '(' + type.getName() + ")new " + typeName + "Impl()";
2249 break;
2250 }
2251 rtn = '(' + type.getName() + ")new " + spec.getFullyQualifiedName() + "()";
2252 }
2253 }
2254
2255 GeneralizableElementFacade generalization = (GeneralizableElementFacade)type;
2256 for (GeneralizableElementFacade spec : generalization.getSpecializations())
2257 {
2258 if (spec.getName().equals(type.getName() + "Impl"))
2259 {
2260 rtn = '(' + type.getName() + ")new " + spec.getFullyQualifiedName() + "Impl()";
2261 }
2262 }
2263 }
2264 else if (typeName.endsWith("[]"))
2265 {
2266 rtn = "{ new " + typeName.substring(0, typeName.length()-2) + "() }";
2267 }
2268 else
2269 {
2270 rtn = "new " + typeName + "()";
2271 }
2272 rtn = StringUtils.replace(rtn, "java.util.Collection", "java.util.ArrayList") + toString;
2273 rtn = StringUtils.replace(rtn, "java.util.Set", "java.util.HashSet") + toString;
2274 if (logger.isDebugEnabled())
2275 {
2276 logger.debug("facade=" + facade + " facadeName=" + facade.getName() + " type=" + type + " typeName=" + typeName + " name=" + name + " isMany=" + isMany + " defaultValue=" + defaultValue + " rtn=" + rtn);
2277 }
2278 } catch (RuntimeException e) {
2279 logger.error(e + " facade=" + facade + " facadeName=" + facade.getName() + " parent=" + parent + " type=" + type + " typeName=" + typeName + " name=" + name + " isMany=" + isMany + " defaultValue=" + defaultValue);
2280 e.printStackTrace();
2281 }
2282 return rtn;
2283 }
2284
2285
2286
2287
2288
2289
2290
2291
2292 private Collection<PackageFacade> getServiceDescendantPackages(ModelElementFacade element, Collection<PackageFacade> pkgRef, Collection<ModelElementFacade> added)
2293 {
2294 if (element==null) return pkgRef;
2295 ModelElementFacade pkg = element.getPackage();
2296 if (pkg==null || pkg.getFullyQualifiedName().indexOf('.') < 1
2297 || pkg.getFullyQualifiedName().startsWith("java.util.")) return pkgRef;
2298
2299 if (!pkgRef.contains(pkg) && pkg instanceof PackageFacade)
2300 {
2301 pkgRef.add((PackageFacade)pkg);
2302 }
2303 if (logger.isDebugEnabled() && pkg.getName().indexOf('.')>0)
2304 {
2305 logger.debug("getServiceDescendantPackages " + element.getFullyQualifiedName() + " package " + pkg.getName() + " size=" + pkgRef.size());
2306 }
2307 if (element instanceof ClassifierFacade)
2308 {
2309 ClassifierFacade classifier = (ClassifierFacade) element;
2310
2311
2312
2313
2314
2315
2316 for (final ModelElementFacade property : (List<ModelElementFacade>)classifier.getAllProperties())
2317 {
2318 if (property instanceof AttributeFacade)
2319 {
2320 AttributeFacade attrib = (AttributeFacade) property;
2321 if (!attrib.getType().equals(classifier) && !added.contains(attrib.getType())
2322 && attrib.getType().getPackageName().indexOf('.')>0)
2323 {
2324 if (logger.isDebugEnabled())
2325 {
2326 logger.debug("getServiceDescendantPackages " + attrib.getName() + ' ' + attrib.getType().getFullyQualifiedName() + " attribute in " + classifier.getFullyQualifiedName() + " size=" + pkgRef.size());
2327 }
2328 added.add(attrib.getType());
2329 pkgRef = getServiceDescendantPackages(attrib.getType(), pkgRef, added);
2330 }
2331 }
2332 else if (property instanceof AssociationEndFacade)
2333 {
2334 AssociationEndFacade assoc = (AssociationEndFacade) property;
2335 if (!assoc.getType().equals(classifier) && !added.contains(assoc.getType())
2336 && assoc.getType().getPackageName().indexOf('.')>0)
2337 {
2338 if (logger.isDebugEnabled())
2339 {
2340 logger.debug("getServiceDescendantPackages " + assoc.getName() + ' ' + assoc.getType().getFullyQualifiedName() + " association in " + classifier.getFullyQualifiedName() + " size=" + pkgRef.size());
2341 }
2342 added.add(assoc.getType());
2343 pkgRef = getServiceDescendantPackages(assoc.getType(), pkgRef, added);
2344 }
2345 }
2346 }
2347 }
2348 return pkgRef;
2349 }
2350
2351
2352
2353
2354
2355
2356
2357
2358 public Collection<PackageFacade> getServiceDescendantPackages(WebServiceLogicImpl service, boolean follow)
2359 {
2360
2361
2362
2363 Collection<PackageFacade> pkgRef = new HashSet<PackageFacade>();
2364
2365 Collection<ModelElementFacade> added = new HashSet<ModelElementFacade>();
2366
2367 for (final WebServiceOperation op : service.getAllowedOperations())
2368 {
2369 if (logger.isDebugEnabled())
2370 {
2371 logger.debug("getServiceDescendantPackages " + service.getFullyQualifiedName() + '.' + op.getName() + " parms=" + op.getParameters().size() + " size=" + pkgRef.size());
2372 }
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385 for (final ParameterFacade arg : op.getParameters())
2386 {
2387 if (!added.contains(arg.getType()))
2388 {
2389 if (logger.isDebugEnabled())
2390 {
2391 logger.debug("getServiceDescendantPackages " + service.getFullyQualifiedName() + '.' + op.getName() + " parameter=" + arg.getName() + " size=" + pkgRef.size());
2392 }
2393 added.add(arg.getType());
2394 pkgRef = getServiceDescendantPackages(arg.getType(), pkgRef, added);
2395 }
2396 }
2397
2398 }
2399
2400 pkgRef.remove(service.getPackage());
2401 return pkgRef;
2402 }
2403
2404
2405
2406
2407
2408
2409
2410
2411 public Collection<ModelElementFacade> getServiceReferences(WebServiceLogicImpl service, boolean follow)
2412 {
2413 Collection<ModelElementFacade> typeRef = new HashSet<ModelElementFacade>();
2414
2415 Collection<ModelElementFacade> opRef = new HashSet<ModelElementFacade>();
2416
2417 String pkg = null;
2418 @SuppressWarnings("unused")
2419 String typeRefs = "";
2420
2421
2422 for (final WebServiceOperation op : service.getAllowedOperations())
2423 {
2424 boolean isMany = false;
2425
2426
2427
2428
2429
2430
2431
2432
2433
2434
2435
2436
2437
2438
2439 for (final ParameterFacade arg : op.getParameters())
2440 {
2441 pkg = arg.getType().getPackageName();
2442
2443 if (arg.getUpper()>1 || arg.getUpper()==-1)
2444 {
2445
2446 isMany = true;
2447 }
2448 if (pkg!=null && pkg.indexOf('.') > 0 && !typeRef.contains(arg.getType()) && !opRef.contains(arg.getType()))
2449 {
2450 opRef.add(arg.getType());
2451 if (logger.isDebugEnabled())
2452 {
2453 typeRefs += arg.getType() + ",";
2454 logger.debug("getServiceReferences parameter " + pkg + '.' + arg.getType().getName());
2455 }
2456 }
2457 }
2458
2459
2460
2461
2462
2463
2464
2465
2466
2467
2468
2469
2470
2471
2472
2473
2474
2475
2476
2477 if (!isMany)
2478 {
2479 typeRef.addAll(opRef);
2480 }
2481 }
2482
2483
2484
2485
2486
2487
2488
2489 if (logger.isDebugEnabled())
2490 {
2491 logger.debug("getServiceReferences typeRef " + service.getPackageName() + '.' + service.getName() + ' ' + typeRef);
2492 }
2493 return typeRef;
2494 }
2495
2496
2497
2498
2499
2500
2501
2502 public static String reversePackage(String packageName)
2503 {
2504 if (StringUtils.isBlank(packageName))
2505 {
2506 return "";
2507 }
2508 if (packageName.startsWith("http://"))
2509 {
2510 packageName = packageName.substring(7);
2511 }
2512 return StringUtils.reverseDelimited(packageName, WebServiceGlobals.NAMESPACE_DELIMITER);
2513 }
2514
2515 private static FastDateFormat df = FastDateFormat.getInstance("MM/dd/yyyy HH:mm:ssZ");
2516
2517
2518
2519
2520
2521
2522
2523 public static String getDate(String format)
2524 {
2525 if (df == null || !format.equals(df.getPattern()))
2526 {
2527 df = FastDateFormat.getInstance(format);
2528 }
2529 return df.format(new Date());
2530 }
2531
2532
2533
2534
2535
2536
2537 public static String getDate()
2538 {
2539 return df.format(new Date());
2540 }
2541
2542
2543
2544
2545
2546
2547
2548
2549
2550
2551
2552
2553 public String getTypeMapping(TypeMappings mappings, String from)
2554 {
2555
2556
2557
2558
2559 return mappings.getTo("datatype::"+from);
2560 }
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583 public static String getSchemaType(
2584 ClassifierFacade type,
2585 TypeMappings schemaTypeMappings,
2586 String namespacePrefix,
2587 String qName,
2588 String wrappedArrayTypePrefix,
2589 boolean withPrefix,
2590 boolean preserveArray)
2591 {
2592 StringBuilder schemaType = new StringBuilder();
2593 String modelName = type.getFullyQualifiedName(true);
2594 if (schemaTypeMappings != null)
2595 {
2596 namespacePrefix += ':';
2597 String mappedValue = schemaTypeMappings.getTo(modelName);
2598 if (!mappedValue.equals(modelName) || StringUtils.isEmpty(type.getPackageName()))
2599 {
2600 schemaType.append(mappedValue);
2601 }
2602 else
2603 {
2604 if (withPrefix)
2605 {
2606 schemaType.append(namespacePrefix);
2607 }
2608 if (type.isArrayType())
2609 {
2610 ClassifierFacade nonArray = type.getNonArray();
2611 if (nonArray != null)
2612 {
2613 if (nonArray instanceof WSDLType)
2614 {
2615 schemaType.append(((WSDLType)nonArray).getName());
2616 }
2617 else if (nonArray instanceof WSDLEnumerationType)
2618 {
2619 schemaType.append(((WSDLEnumerationType)nonArray).getName());
2620 }
2621 }
2622 }
2623 else
2624 {
2625 schemaType.append(qName);
2626 }
2627 }
2628
2629 schemaType = new StringBuilder(schemaType.toString().replaceAll("\\[\\]", ""));
2630 if (preserveArray && type.isArrayType())
2631 {
2632 int insertIndex = namespacePrefix.length();
2633 if (!schemaType.toString().startsWith(namespacePrefix))
2634 {
2635 if (withPrefix)
2636 {
2637
2638
2639 schemaType.insert(0, namespacePrefix);
2640 }
2641 else
2642 {
2643
2644
2645 insertIndex = 0;
2646 }
2647 }
2648 schemaType.insert(insertIndex, wrappedArrayTypePrefix);
2649 }
2650 if (withPrefix && !schemaType.toString().startsWith(namespacePrefix))
2651 {
2652 schemaType.insert(0, WebServiceGlobals.XSD_NAMESPACE_PREFIX);
2653 }
2654 }
2655 return schemaType.toString();
2656 }
2657
2658
2659
2660
2661
2662
2663
2664
2665 public static boolean isSimpleType(ModelElementFacade element)
2666 {
2667 boolean simple = false;
2668 String typeName = null;
2669 ClassifierFacade type = null;
2670 boolean many = false;
2671 if (element instanceof AttributeFacade)
2672 {
2673 AttributeFacade attrib = (AttributeFacade)element;
2674 type = attrib.getType();
2675 many = attrib.isMany() && !type.isArrayType() && !type.isCollectionType();
2676 }
2677 else if (element instanceof AssociationEndFacade)
2678 {
2679 AssociationEndFacade association = (AssociationEndFacade)element;
2680 type = association.getType();
2681 many = association.isMany() && !type.isArrayType() && !type.isCollectionType();
2682 }
2683 else if (element instanceof ParameterFacade)
2684 {
2685 ParameterFacade param = (ParameterFacade)element;
2686 type = param.getType();
2687 many = param.isMany() && !type.isArrayType() && !type.isCollectionType();
2688 }
2689 else if (element instanceof WSDLTypeAttributeLogic)
2690 {
2691 WSDLTypeAttributeLogic attrib = (WSDLTypeAttributeLogic)element;
2692 type = attrib.getType();
2693 many = attrib.isMany() && !type.isArrayType() && !type.isCollectionType();
2694 }
2695 else if (element instanceof WSDLTypeAssociationEndLogic)
2696 {
2697 WSDLTypeAssociationEndLogic association = (WSDLTypeAssociationEndLogic)element;
2698 type = association.getType();
2699 many = association.isMany() && !type.isArrayType() && !type.isCollectionType();
2700 }
2701 else if (element instanceof WebServiceParameterLogic)
2702 {
2703 WebServiceParameterLogic param = (WebServiceParameterLogic)element;
2704 type = param.getType();
2705 many = param.isMany() && !type.isArrayType() && !type.isCollectionType();
2706 }
2707 else if (element instanceof ClassifierFacade)
2708 {
2709 ClassifierFacade classifier = (ClassifierFacade)element;
2710 type = classifier;
2711 }
2712 else
2713 {
2714 return simple;
2715 }
2716 typeName = type.getFullyQualifiedName();
2717 if (type.isPrimitive() || typeName.startsWith("java.lang.") || typeName.startsWith("java.util.")
2718 || !typeName.contains("."))
2719 {
2720 if (!many)
2721 {
2722 simple = true;
2723 }
2724 }
2725 return simple;
2726 }
2727 }