@Test public void shouldProcessGetter() throws Exception { Method getServerDate = getAccessibleMethod(Sample.class, "getServerDate", new Class[0]); processor.process(getServerDate); verify(schemaHolder).getType(Date.class); Collection<FieldDto> fields = processor.getElements(); assertEquals(1, fields.size()); FieldDto field = fields.iterator().next(); assertEquals("Server Date", field.getBasic().getDisplayName()); assertEquals("serverDate", field.getBasic().getName()); assertFalse(field.getBasic().isRequired()); assertEquals("", field.getBasic().getDefaultValue()); assertEquals("", field.getBasic().getTooltip()); assertEquals("yyyy-mm-dd", field.getBasic().getPlaceholder()); assertEquals(entity.getId(), field.getEntityId()); assertEquals(TypeDto.DATE, field.getType()); }
@Override protected void process(AnnotatedElement element) { AccessibleObject ac = (AccessibleObject) element; Class<?> classType = MemberUtil.getCorrectType(ac); Class<?> genericType = MemberUtil.getGenericType(element); Class<?> declaringClass = MemberUtil.getDeclaringClass(ac); Class<?> valueType = null; if (null != classType) { if (Map.class.isAssignableFrom(classType)) { valueType = MemberUtil.getGenericType(element, 1); } String fieldName = MemberUtil.getFieldName(ac); FieldDto currentField = getFieldByName(declaringClass.getName(), fieldName); boolean isRelationship = ReflectionsUtil.hasAnnotationClassLoaderSafe( genericType, genericType, Entity.class); boolean isOwningSide = isRelationship && getMappedBy(ac) == null; boolean isCollection = Collection.class.isAssignableFrom(classType); Field annotation = getAnnotationClassLoaderSafe(ac, classType, Field.class); String relatedFieldName = getRelatedFieldName(ac, classType, genericType, declaringClass, isRelationship); java.lang.reflect.Field relatedField = (relatedFieldName != null) ? ReflectionUtils.findField(genericType, relatedFieldName) : null; boolean relatedFieldIsCollection = isRelatedFieldCollection(relatedField); boolean isTextArea = getAnnotationValue(annotation, TYPE, EMPTY).equalsIgnoreCase("text"); TypeDto type = getCorrectType(classType, isCollection, isRelationship, relatedFieldIsCollection); FieldBasicDto basic = new FieldBasicDto(); basic.setDisplayName(isUiChanged(currentField) ? currentField.getBasic().getDisplayName() : getAnnotationValue(annotation, DISPLAY_NAME, convertFromCamelCase(fieldName))); basic.setName(fieldName); basic.setDefaultValue(getDefaultValueForField(annotation, classType)); basic.setRequired(isFieldRequired(annotation, classType)); basic.setUnique(isFieldUnique(ac)); FieldDto field = new FieldDto(); if (null != annotation) { basic.setTooltip(isUiChanged(currentField) ? currentField.getBasic().getTooltip() : annotation.tooltip()); basic.setPlaceholder(annotation.placeholder()); String fn = getAnnotationValue(annotation, NAME, EMPTY); if (!fn.equals(EMPTY)) { field.addMetadata(new MetadataDto(DATABASE_COLUMN_NAME, fn)); } } field.setEntityId(entity.getId()); field.setType(type); field.setBasic(basic); field.setValidation(createValidation(ac, type)); field.setReadOnly(true); field.setNonEditable(false); field.setNonDisplayable(false); field.setUiChanged(isUiChanged(currentField)); field.setUiFilterable(isUiFilterable(currentField)); setFieldSettings(ac, classType, isRelationship, isTextArea, field); setFieldMetadata(classType, genericType, valueType, isCollection, isRelationship, relatedFieldIsCollection, isOwningSide, field, relatedFieldName); add(field); } else { LOGGER.warn("Field type is unknown in: {}", ac); } }
FieldProcessor extends AbstractListProcessor<Field, FieldDto> { @Override protected void process(AnnotatedElement element) { AccessibleObject ac = (AccessibleObject) element; Class<?> classType = MemberUtil.getCorrectType(ac); Class<?> genericType = MemberUtil.getGenericType(element); Class<?> declaringClass = MemberUtil.getDeclaringClass(ac); Class<?> valueType = null; if (null != classType) { if (Map.class.isAssignableFrom(classType)) { valueType = MemberUtil.getGenericType(element, 1); } String fieldName = MemberUtil.getFieldName(ac); FieldDto currentField = getFieldByName(declaringClass.getName(), fieldName); boolean isRelationship = ReflectionsUtil.hasAnnotationClassLoaderSafe( genericType, genericType, Entity.class); boolean isOwningSide = isRelationship && getMappedBy(ac) == null; boolean isCollection = Collection.class.isAssignableFrom(classType); Field annotation = getAnnotationClassLoaderSafe(ac, classType, Field.class); String relatedFieldName = getRelatedFieldName(ac, classType, genericType, declaringClass, isRelationship); java.lang.reflect.Field relatedField = (relatedFieldName != null) ? ReflectionUtils.findField(genericType, relatedFieldName) : null; boolean relatedFieldIsCollection = isRelatedFieldCollection(relatedField); boolean isTextArea = getAnnotationValue(annotation, TYPE, EMPTY).equalsIgnoreCase("text"); TypeDto type = getCorrectType(classType, isCollection, isRelationship, relatedFieldIsCollection); FieldBasicDto basic = new FieldBasicDto(); basic.setDisplayName(isUiChanged(currentField) ? currentField.getBasic().getDisplayName() : getAnnotationValue(annotation, DISPLAY_NAME, convertFromCamelCase(fieldName))); basic.setName(fieldName); basic.setDefaultValue(getDefaultValueForField(annotation, classType)); basic.setRequired(isFieldRequired(annotation, classType)); basic.setUnique(isFieldUnique(ac)); FieldDto field = new FieldDto(); if (null != annotation) { basic.setTooltip(isUiChanged(currentField) ? currentField.getBasic().getTooltip() : annotation.tooltip()); basic.setPlaceholder(annotation.placeholder()); String fn = getAnnotationValue(annotation, NAME, EMPTY); if (!fn.equals(EMPTY)) { field.addMetadata(new MetadataDto(DATABASE_COLUMN_NAME, fn)); } } field.setEntityId(entity.getId()); field.setType(type); field.setBasic(basic); field.setValidation(createValidation(ac, type)); field.setReadOnly(true); field.setNonEditable(false); field.setNonDisplayable(false); field.setUiChanged(isUiChanged(currentField)); field.setUiFilterable(isUiFilterable(currentField)); setFieldSettings(ac, classType, isRelationship, isTextArea, field); setFieldMetadata(classType, genericType, valueType, isCollection, isRelationship, relatedFieldIsCollection, isOwningSide, field, relatedFieldName); add(field); } else { LOGGER.warn("Field type is unknown in: {}", ac); } } }
FieldProcessor extends AbstractListProcessor<Field, FieldDto> { @Override protected void process(AnnotatedElement element) { AccessibleObject ac = (AccessibleObject) element; Class<?> classType = MemberUtil.getCorrectType(ac); Class<?> genericType = MemberUtil.getGenericType(element); Class<?> declaringClass = MemberUtil.getDeclaringClass(ac); Class<?> valueType = null; if (null != classType) { if (Map.class.isAssignableFrom(classType)) { valueType = MemberUtil.getGenericType(element, 1); } String fieldName = MemberUtil.getFieldName(ac); FieldDto currentField = getFieldByName(declaringClass.getName(), fieldName); boolean isRelationship = ReflectionsUtil.hasAnnotationClassLoaderSafe( genericType, genericType, Entity.class); boolean isOwningSide = isRelationship && getMappedBy(ac) == null; boolean isCollection = Collection.class.isAssignableFrom(classType); Field annotation = getAnnotationClassLoaderSafe(ac, classType, Field.class); String relatedFieldName = getRelatedFieldName(ac, classType, genericType, declaringClass, isRelationship); java.lang.reflect.Field relatedField = (relatedFieldName != null) ? ReflectionUtils.findField(genericType, relatedFieldName) : null; boolean relatedFieldIsCollection = isRelatedFieldCollection(relatedField); boolean isTextArea = getAnnotationValue(annotation, TYPE, EMPTY).equalsIgnoreCase("text"); TypeDto type = getCorrectType(classType, isCollection, isRelationship, relatedFieldIsCollection); FieldBasicDto basic = new FieldBasicDto(); basic.setDisplayName(isUiChanged(currentField) ? currentField.getBasic().getDisplayName() : getAnnotationValue(annotation, DISPLAY_NAME, convertFromCamelCase(fieldName))); basic.setName(fieldName); basic.setDefaultValue(getDefaultValueForField(annotation, classType)); basic.setRequired(isFieldRequired(annotation, classType)); basic.setUnique(isFieldUnique(ac)); FieldDto field = new FieldDto(); if (null != annotation) { basic.setTooltip(isUiChanged(currentField) ? currentField.getBasic().getTooltip() : annotation.tooltip()); basic.setPlaceholder(annotation.placeholder()); String fn = getAnnotationValue(annotation, NAME, EMPTY); if (!fn.equals(EMPTY)) { field.addMetadata(new MetadataDto(DATABASE_COLUMN_NAME, fn)); } } field.setEntityId(entity.getId()); field.setType(type); field.setBasic(basic); field.setValidation(createValidation(ac, type)); field.setReadOnly(true); field.setNonEditable(false); field.setNonDisplayable(false); field.setUiChanged(isUiChanged(currentField)); field.setUiFilterable(isUiFilterable(currentField)); setFieldSettings(ac, classType, isRelationship, isTextArea, field); setFieldMetadata(classType, genericType, valueType, isCollection, isRelationship, relatedFieldIsCollection, isOwningSide, field, relatedFieldName); add(field); } else { LOGGER.warn("Field type is unknown in: {}", ac); } }  }
FieldProcessor extends AbstractListProcessor<Field, FieldDto> { @Override protected void process(AnnotatedElement element) { AccessibleObject ac = (AccessibleObject) element; Class<?> classType = MemberUtil.getCorrectType(ac); Class<?> genericType = MemberUtil.getGenericType(element); Class<?> declaringClass = MemberUtil.getDeclaringClass(ac); Class<?> valueType = null; if (null != classType) { if (Map.class.isAssignableFrom(classType)) { valueType = MemberUtil.getGenericType(element, 1); } String fieldName = MemberUtil.getFieldName(ac); FieldDto currentField = getFieldByName(declaringClass.getName(), fieldName); boolean isRelationship = ReflectionsUtil.hasAnnotationClassLoaderSafe( genericType, genericType, Entity.class); boolean isOwningSide = isRelationship && getMappedBy(ac) == null; boolean isCollection = Collection.class.isAssignableFrom(classType); Field annotation = getAnnotationClassLoaderSafe(ac, classType, Field.class); String relatedFieldName = getRelatedFieldName(ac, classType, genericType, declaringClass, isRelationship); java.lang.reflect.Field relatedField = (relatedFieldName != null) ? ReflectionUtils.findField(genericType, relatedFieldName) : null; boolean relatedFieldIsCollection = isRelatedFieldCollection(relatedField); boolean isTextArea = getAnnotationValue(annotation, TYPE, EMPTY).equalsIgnoreCase("text"); TypeDto type = getCorrectType(classType, isCollection, isRelationship, relatedFieldIsCollection); FieldBasicDto basic = new FieldBasicDto(); basic.setDisplayName(isUiChanged(currentField) ? currentField.getBasic().getDisplayName() : getAnnotationValue(annotation, DISPLAY_NAME, convertFromCamelCase(fieldName))); basic.setName(fieldName); basic.setDefaultValue(getDefaultValueForField(annotation, classType)); basic.setRequired(isFieldRequired(annotation, classType)); basic.setUnique(isFieldUnique(ac)); FieldDto field = new FieldDto(); if (null != annotation) { basic.setTooltip(isUiChanged(currentField) ? currentField.getBasic().getTooltip() : annotation.tooltip()); basic.setPlaceholder(annotation.placeholder()); String fn = getAnnotationValue(annotation, NAME, EMPTY); if (!fn.equals(EMPTY)) { field.addMetadata(new MetadataDto(DATABASE_COLUMN_NAME, fn)); } } field.setEntityId(entity.getId()); field.setType(type); field.setBasic(basic); field.setValidation(createValidation(ac, type)); field.setReadOnly(true); field.setNonEditable(false); field.setNonDisplayable(false); field.setUiChanged(isUiChanged(currentField)); field.setUiFilterable(isUiFilterable(currentField)); setFieldSettings(ac, classType, isRelationship, isTextArea, field); setFieldMetadata(classType, genericType, valueType, isCollection, isRelationship, relatedFieldIsCollection, isOwningSide, field, relatedFieldName); add(field); } else { LOGGER.warn("Field type is unknown in: {}", ac); } }  @Override Class<Field> getAnnotationType(); @Override Collection<FieldDto> getProcessingResult(); void setEntity(EntityDto entity); void setClazz(Class clazz); }
FieldProcessor extends AbstractListProcessor<Field, FieldDto> { @Override protected void process(AnnotatedElement element) { AccessibleObject ac = (AccessibleObject) element; Class<?> classType = MemberUtil.getCorrectType(ac); Class<?> genericType = MemberUtil.getGenericType(element); Class<?> declaringClass = MemberUtil.getDeclaringClass(ac); Class<?> valueType = null; if (null != classType) { if (Map.class.isAssignableFrom(classType)) { valueType = MemberUtil.getGenericType(element, 1); } String fieldName = MemberUtil.getFieldName(ac); FieldDto currentField = getFieldByName(declaringClass.getName(), fieldName); boolean isRelationship = ReflectionsUtil.hasAnnotationClassLoaderSafe( genericType, genericType, Entity.class); boolean isOwningSide = isRelationship && getMappedBy(ac) == null; boolean isCollection = Collection.class.isAssignableFrom(classType); Field annotation = getAnnotationClassLoaderSafe(ac, classType, Field.class); String relatedFieldName = getRelatedFieldName(ac, classType, genericType, declaringClass, isRelationship); java.lang.reflect.Field relatedField = (relatedFieldName != null) ? ReflectionUtils.findField(genericType, relatedFieldName) : null; boolean relatedFieldIsCollection = isRelatedFieldCollection(relatedField); boolean isTextArea = getAnnotationValue(annotation, TYPE, EMPTY).equalsIgnoreCase("text"); TypeDto type = getCorrectType(classType, isCollection, isRelationship, relatedFieldIsCollection); FieldBasicDto basic = new FieldBasicDto(); basic.setDisplayName(isUiChanged(currentField) ? currentField.getBasic().getDisplayName() : getAnnotationValue(annotation, DISPLAY_NAME, convertFromCamelCase(fieldName))); basic.setName(fieldName); basic.setDefaultValue(getDefaultValueForField(annotation, classType)); basic.setRequired(isFieldRequired(annotation, classType)); basic.setUnique(isFieldUnique(ac)); FieldDto field = new FieldDto(); if (null != annotation) { basic.setTooltip(isUiChanged(currentField) ? currentField.getBasic().getTooltip() : annotation.tooltip()); basic.setPlaceholder(annotation.placeholder()); String fn = getAnnotationValue(annotation, NAME, EMPTY); if (!fn.equals(EMPTY)) { field.addMetadata(new MetadataDto(DATABASE_COLUMN_NAME, fn)); } } field.setEntityId(entity.getId()); field.setType(type); field.setBasic(basic); field.setValidation(createValidation(ac, type)); field.setReadOnly(true); field.setNonEditable(false); field.setNonDisplayable(false); field.setUiChanged(isUiChanged(currentField)); field.setUiFilterable(isUiFilterable(currentField)); setFieldSettings(ac, classType, isRelationship, isTextArea, field); setFieldMetadata(classType, genericType, valueType, isCollection, isRelationship, relatedFieldIsCollection, isOwningSide, field, relatedFieldName); add(field); } else { LOGGER.warn("Field type is unknown in: {}", ac); } }  @Override Class<Field> getAnnotationType(); @Override Collection<FieldDto> getProcessingResult(); void setEntity(EntityDto entity); void setClazz(Class clazz);  }