public boolean required() {
   return core.required();
 }
示例#2
0
  protected boolean isMandatory(Object bean, String propertyName) {
    // lets look at the setter method and see if its got a @Required
    // annotation
    if (bean instanceof AbstractNode) {
      AbstractNode node = (AbstractNode) bean;
      Class<?> camelClass = node.getCamelDefinitionClass();
      if (camelClass != null) {
        XmlAccessorType accessorType = camelClass.getAnnotation(XmlAccessorType.class);
        boolean useMethods = true;
        if (accessorType != null) {
          if (accessorType.value().equals(XmlAccessType.FIELD)) {
            useMethods = false;
          }
        }
        try {
          BeanInfo beanInfo = Introspector.getBeanInfo(camelClass);
          PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
          if (propertyDescriptors != null) {
            for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
              if (propertyName.equals(propertyDescriptor.getName())) {
                Method writeMethod = propertyDescriptor.getWriteMethod();
                if (writeMethod != null) {
                  Required annotation = writeMethod.getAnnotation(Required.class);
                  if (annotation != null) {
                    return true;
                  }
                  if (useMethods) {
                    XmlElement element = writeMethod.getAnnotation(XmlElement.class);
                    if (element != null && element.required()) {
                      return true;
                    }
                    XmlAttribute attribute = writeMethod.getAnnotation(XmlAttribute.class);
                    if (attribute != null && attribute.required()) {
                      return true;
                    }
                  }
                }
                break;
              }
            }
          }
          if (!useMethods) {
            Field[] fields = camelClass.getDeclaredFields();
            for (Field field : fields) {
              if (propertyName.equals(field.getName())) {
                Required annotation = field.getAnnotation(Required.class);
                if (annotation != null) {
                  return true;
                }
                XmlElement element = field.getAnnotation(XmlElement.class);
                if (element != null && element.required()) {
                  return true;
                }
                XmlAttribute attribute = field.getAnnotation(XmlAttribute.class);
                if (attribute != null && attribute.required()) {
                  return true;
                }
              }
            }
          }
        } catch (IntrospectionException e) {
          // ignore
        }
      }
    }

    // expression is mandatory on resequence
    if (node instanceof Resequence && "expression".equals(propertyName)) {
      return true;
    }

    // lets make all URI properties mandatory by default to avoid complex
    // validation with ref v uri
    boolean answer =
        ("uri".equals(propertyName) || propertyName.endsWith("Uri"))
            || (bean instanceof Aggregate && "strategyRef".equals(propertyName))
            || (bean instanceof ConvertBody && "type".equals(propertyName))
            || (bean instanceof ExpressionDefinition && isMandatoryExpression())
            || (bean instanceof Log && "message".equals(propertyName))
            || (bean instanceof Process && "ref".equals(propertyName))
            || (bean instanceof RemoveHeader && "headerName".equals(propertyName))
            || (bean instanceof RemoveProperty && "propertyName".equals(propertyName))
            || (bean instanceof SetHeader && "headerName".equals(propertyName))
            || (bean instanceof SetOutHeader && "headerName".equals(propertyName))
            || (bean instanceof SetProperty && "propertyName".equals(propertyName));
    return answer;
  }
 public String namespace() {
   return core.namespace();
 }
示例#4
0
 private void processFieldRelatedAnnotations(
     Annotation annots[], String fieldName, Type defaultGenericType) {
   WrappedElementInfo wrappedInfo = null;
   for (Annotation annot : annots) {
     if (annot instanceof XmlElementWrapper) {
       XmlElementWrapper wrapper = (XmlElementWrapper) annot;
       wrappedInfo = new WrappedElementInfo(wrapper, fieldName);
       jaxbElemNodeInfo.add(wrappedInfo);
       break;
     }
   }
   for (Annotation annot : annots) {
     if (annot instanceof XmlValue) {
       elementValue = new JaxbValueInfo((XmlValue) annot, fieldName, defaultGenericType);
     } else if (annot instanceof XmlAttribute) {
       XmlAttribute attr = (XmlAttribute) annot;
       String attrName = attr.name();
       if ((attrName == null) || DEFAULT_MARKER.equals(attrName)) {
         attrName = fieldName;
       }
       this.setXmlAttributeInfo(attr, fieldName, defaultGenericType);
       this.attributeNames.add(attrName);
     } else if (annot instanceof XmlElement) {
       XmlElement xmlElem = (XmlElement) annot;
       if (wrappedInfo == null) {
         setXmlElementInfo(xmlElem, fieldName, defaultGenericType);
       } else {
         wrappedInfo.add(xmlElem, fieldName, defaultGenericType);
       }
     } else if (annot instanceof XmlElementRef) {
       XmlElementRef xmlElemR = (XmlElementRef) annot;
       if (wrappedInfo == null) {
         setXmlElementInfo(xmlElemR, null, null);
       } else {
         wrappedInfo.add(xmlElemR, null, null);
       }
     } else if (annot instanceof XmlElements) {
       JaxbPseudoNodeChoiceInfo choiceNode =
           new JaxbPseudoNodeChoiceInfo(fieldName, defaultGenericType);
       if (wrappedInfo == null) {
         jaxbElemNodeInfo.add(choiceNode);
       } else {
         wrappedInfo.add(choiceNode);
       }
       XmlElements xmlElemsAnnot = (XmlElements) annot;
       for (XmlElement xmlE : xmlElemsAnnot.value()) {
         choiceNode.add(xmlE);
       }
     } else if (annot instanceof XmlElementRefs) {
       JaxbPseudoNodeChoiceInfo choiceNode =
           new JaxbPseudoNodeChoiceInfo(fieldName, defaultGenericType);
       if (wrappedInfo == null) {
         jaxbElemNodeInfo.add(choiceNode);
       } else {
         wrappedInfo.add(choiceNode);
       }
       XmlElementRefs elemRefs = (XmlElementRefs) annot;
       for (XmlElementRef xmlE : elemRefs.value()) {
         choiceNode.add(xmlE);
       }
     }
   }
 }