private String getDateTimeFormat() { String format = "DateTimeFormat.getFormat(DateTimeFormat.PredefinedFormat.DATE_SHORT)"; if (annotations == null || annotations.isEmpty()) { return format; } String style = ""; AnnotationMetadata annotation = MemberFindingUtils.getAnnotationOfType(annotations, DATE_TIME_FORMAT); if (annotation != null) { AnnotationAttributeValue<?> attr = annotation.getAttribute(new JavaSymbolName("style")); if (attr != null) { style = (String) attr.getValue(); } } if (StringUtils.hasText(style)) { if (style.equals("S")) { format = "DateTimeFormat.getFormat(DateTimeFormat.PredefinedFormat.DATE_TIME_SHORT)"; } else if (style.equals("M")) { format = "DateTimeFormat.getFormat(DateTimeFormat.PredefinedFormat.DATE_TIME_MEDIUM)"; } else if (style.equals("F")) { format = "DateTimeFormat.getFormat(DateTimeFormat.PredefinedFormat.DATE_TIME_FULL)"; } else if (style.equals("S-")) { format = "DateTimeFormat.getFormat(DateTimeFormat.PredefinedFormat.DATE_SHORT)"; } else if (style.equals("M-")) { format = "DateTimeFormat.getFormat(DateTimeFormat.PredefinedFormat.DATE_MEDIUM)"; } else if (style.equals("F-")) { format = "DateTimeFormat.getFormat(DateTimeFormat.PredefinedFormat.DATE_FULL)"; } } return format; }
public static JavaType lookupTargetType( final ClassOrInterfaceTypeDetails cid, final boolean proxy) { JavaType stringBasedAnnotation = SERVICE_NAME; JavaType classBasedAnnotation = SERVICE; if (proxy) { stringBasedAnnotation = PROXY_FOR_NAME; classBasedAnnotation = PROXY_FOR; } AnnotationMetadata serviceNameAnnotation = MemberFindingUtils.getAnnotationOfType(cid.getAnnotations(), stringBasedAnnotation); if (serviceNameAnnotation != null) { AnnotationAttributeValue<String> serviceNameAttributeValue = serviceNameAnnotation.getAttribute("value"); if (serviceNameAttributeValue != null) { return new JavaType(serviceNameAttributeValue.getValue()); } } serviceNameAnnotation = MemberFindingUtils.getAnnotationOfType(cid.getAnnotations(), classBasedAnnotation); if (serviceNameAnnotation != null) { AnnotationAttributeValue<JavaType> serviceAttributeValue = serviceNameAnnotation.getAttribute("value"); if (serviceAttributeValue != null) { return serviceAttributeValue.getValue(); } } return null; }
private Set<ClassOrInterfaceTypeDetails> getManagedIdentifiers() { final Set<ClassOrInterfaceTypeDetails> managedIdentifierTypes = new LinkedHashSet<ClassOrInterfaceTypeDetails>(); final Set<ClassOrInterfaceTypeDetails> identifierTypes = typeLocationService.findClassesOrInterfaceDetailsWithAnnotation(ROO_IDENTIFIER); for (final ClassOrInterfaceTypeDetails managedIdentifierType : identifierTypes) { final AnnotationMetadata identifierAnnotation = managedIdentifierType.getTypeAnnotation(ROO_IDENTIFIER); final AnnotationAttributeValue<?> attrValue = identifierAnnotation.getAttribute(DB_MANAGED); if (attrValue != null && (Boolean) attrValue.getValue()) { managedIdentifierTypes.add(managedIdentifierType); } } return managedIdentifierTypes; }
public String getFormatter() { if (isCollectionOfProxy()) { return getCollectionRenderer() + ".render"; } else if (isDate()) { return getDateTimeFormat() + ".format"; } else if (type.equals(JavaType.INT_OBJECT) || type.equals(JavaType.FLOAT_OBJECT) || type.equals(JavaType.DOUBLE_OBJECT) || type.equals(BIG_INTEGER) || type.equals(BIG_DECIMAL)) { String formatter = "String.valueOf"; if (annotations == null || annotations.isEmpty()) { return formatter; } AnnotationMetadata annotation = MemberFindingUtils.getAnnotationOfType(annotations, NUMBER_FORMAT); if (annotation != null) { AnnotationAttributeValue<?> attr = annotation.getAttribute(new JavaSymbolName("style")); if (attr != null) { String style = attr.getValue().toString(); if ("org.springframework.format.annotation.NumberFormat.Style.CURRENCY".equals(style)) { formatter = "NumberFormat.getCurrencyFormat().format"; } else if ("org.springframework.format.annotation.NumberFormat.Style.PERCENT" .equals(style)) { formatter = "NumberFormat.getPercentFormat().format"; } else { formatter = "NumberFormat.getDecimalFormat().format"; } } else { formatter = "NumberFormat.getDecimalFormat().format"; } } return formatter; } else if (isProxy()) { return getProxyRendererType() + ".instance().render"; } else { return "String.valueOf"; } }
/** * Returns the type of ID that DBRE should use for the given entity * * @param entity the entity for which to get the ID type (required) * @return a non-<code>null</code> ID type */ private JavaType getIdentifierType(final JavaType entity) { final PhysicalTypeMetadata governorPhysicalTypeMetadata = getPhysicalTypeMetadata(entity); if (governorPhysicalTypeMetadata != null) { final ClassOrInterfaceTypeDetails governorTypeDetails = governorPhysicalTypeMetadata.getMemberHoldingTypeDetails(); final AnnotationMetadata jpaAnnotation = getJpaAnnotation(governorTypeDetails); if (jpaAnnotation != null) { final AnnotationAttributeValue<?> identifierTypeAttribute = jpaAnnotation.getAttribute(new JavaSymbolName(IDENTIFIER_TYPE)); if (identifierTypeAttribute != null) { // The identifierType attribute exists, so get its value final JavaType identifierType = (JavaType) identifierTypeAttribute.getValue(); if (identifierType != null && !JdkJavaType.isPartOfJavaLang(identifierType)) { return identifierType; } } } } // The JPA annotation's "identifierType" attribute does not exist or is // not a simple type, so return a default return new JavaType(entity.getFullyQualifiedTypeName() + PRIMARY_KEY_SUFFIX); }
public boolean updateTypeAnnotation( AnnotationMetadata annotation, Set<JavaSymbolName> attributesToDeleteIfPresent) { boolean hasChanged = false; // We are going to build a replacement AnnotationMetadata. // This variable tracks the new attribute values the replacement will hold. Map<JavaSymbolName, AnnotationAttributeValue<?>> replacementAttributeValues = new LinkedHashMap<JavaSymbolName, AnnotationAttributeValue<?>>(); AnnotationMetadataBuilder existingBuilder = MemberFindingUtils.getDeclaredTypeAnnotation(this, annotation.getAnnotationType()); if (existingBuilder == null) { // Not already present, so just go and add it for (JavaSymbolName incomingAttributeName : annotation.getAttributeNames()) { // Do not copy incoming attributes which exist in the attributesToDeleteIfPresent Set if (attributesToDeleteIfPresent == null || !attributesToDeleteIfPresent.contains(incomingAttributeName)) { AnnotationAttributeValue<?> incomingValue = annotation.getAttribute(incomingAttributeName); replacementAttributeValues.put(incomingAttributeName, incomingValue); } } AnnotationMetadataBuilder replacement = new AnnotationMetadataBuilder( annotation.getAnnotationType(), new ArrayList<AnnotationAttributeValue<?>>(replacementAttributeValues.values())); addAnnotation(replacement); return true; } AnnotationMetadata existing = existingBuilder.build(); // Copy the existing attributes into the new attributes for (JavaSymbolName existingAttributeName : existing.getAttributeNames()) { if (attributesToDeleteIfPresent != null && attributesToDeleteIfPresent.contains(existingAttributeName)) { hasChanged = true; } else { AnnotationAttributeValue<?> existingValue = existing.getAttribute(existingAttributeName); replacementAttributeValues.put(existingAttributeName, existingValue); } } // Now we ensure every incoming attribute replaces the existing for (JavaSymbolName incomingAttributeName : annotation.getAttributeNames()) { AnnotationAttributeValue<?> incomingValue = annotation.getAttribute(incomingAttributeName); // Add this attribute to the end of the list if the attribute is not already present if (replacementAttributeValues.keySet().contains(incomingAttributeName)) { // There was already an attribute. Need to determine if this new attribute value is // materially different AnnotationAttributeValue<?> existingValue = replacementAttributeValues.get(incomingAttributeName); Assert.notNull(existingValue, "Existing value should have been provided by earlier loop"); if (!existingValue.equals(incomingValue)) { replacementAttributeValues.put(incomingAttributeName, incomingValue); hasChanged = true; } } else if (attributesToDeleteIfPresent == null || !attributesToDeleteIfPresent.contains(incomingAttributeName)) { // This is a new attribute that does not already exist, so add it to the end of the // replacement attributes replacementAttributeValues.put(incomingAttributeName, incomingValue); hasChanged = true; } } // Were there any material changes? if (!hasChanged) { return false; } // Make a new AnnotationMetadata representing the replacement AnnotationMetadataBuilder replacement = new AnnotationMetadataBuilder( annotation.getAnnotationType(), new ArrayList<AnnotationAttributeValue<?>>(replacementAttributeValues.values())); annotations.remove(existingBuilder); addAnnotation(replacement); return true; }
public void notify(String upstreamDependency, String downstreamDependency) { ProjectMetadata projectMetadata = projectOperations.getProjectMetadata(); if (projectMetadata == null) { return; } if (MetadataIdentificationUtils.isIdentifyingClass(downstreamDependency)) { Assert.isTrue( MetadataIdentificationUtils.getMetadataClass(upstreamDependency) .equals( MetadataIdentificationUtils.getMetadataClass( PhysicalTypeIdentifier.getMetadataIdentiferType())), "Expected class-level notifications only for PhysicalTypeIdentifier (not '" + upstreamDependency + "')"); ClassOrInterfaceTypeDetails cid = typeLocationService.getTypeForIdentifier(upstreamDependency); boolean processed = false; if (MemberFindingUtils.getAnnotationOfType(cid.getAnnotations(), RooJavaType.ROO_GWT_REQUEST) != null) { ClassOrInterfaceTypeDetails proxy = gwtTypeService.lookupProxyFromRequest(cid); if (proxy != null) { JavaType typeName = PhysicalTypeIdentifier.getJavaType(proxy.getDeclaredByMetadataId()); Path typePath = PhysicalTypeIdentifier.getPath(proxy.getDeclaredByMetadataId()); downstreamDependency = GwtLocatorMetadata.createIdentifier(typeName, typePath); processed = true; } } if (!processed && MemberFindingUtils.getAnnotationOfType(cid.getAnnotations(), RooJavaType.ROO_GWT_PROXY) == null) { boolean found = false; for (ClassOrInterfaceTypeDetails classOrInterfaceTypeDetails : typeLocationService.findClassesOrInterfaceDetailsWithAnnotation( RooJavaType.ROO_GWT_PROXY)) { AnnotationMetadata annotationMetadata = GwtUtils.getFirstAnnotation( classOrInterfaceTypeDetails, GwtUtils.ROO_PROXY_REQUEST_ANNOTATIONS); if (annotationMetadata != null) { AnnotationAttributeValue<?> attributeValue = annotationMetadata.getAttribute("value"); if (attributeValue != null) { String mirrorName = GwtUtils.getStringValue(attributeValue); if (mirrorName != null && cid.getName().getFullyQualifiedTypeName().equals(attributeValue.getValue())) { found = true; JavaType typeName = PhysicalTypeIdentifier.getJavaType( classOrInterfaceTypeDetails.getDeclaredByMetadataId()); Path typePath = PhysicalTypeIdentifier.getPath( classOrInterfaceTypeDetails.getDeclaredByMetadataId()); downstreamDependency = GwtLocatorMetadata.createIdentifier(typeName, typePath); break; } } } } if (!found) { return; } } else if (!processed) { // A physical Java type has changed, and determine what the corresponding local metadata // identification string would have been JavaType typeName = PhysicalTypeIdentifier.getJavaType(upstreamDependency); Path typePath = PhysicalTypeIdentifier.getPath(upstreamDependency); downstreamDependency = GwtLocatorMetadata.createIdentifier(typeName, typePath); } // We only need to proceed if the downstream dependency relationship is not already registered // (if it's already registered, the event will be delivered directly later on) if (metadataDependencyRegistry .getDownstream(upstreamDependency) .contains(downstreamDependency)) { return; } } // We should now have an instance-specific "downstream dependency" that can be processed by this // class Assert.isTrue( MetadataIdentificationUtils.getMetadataClass(downstreamDependency) .equals(MetadataIdentificationUtils.getMetadataClass(getProvidesType())), "Unexpected downstream notification for '" + downstreamDependency + "' to this provider (which uses '" + getProvidesType() + "'"); metadataService.get(downstreamDependency, true); }
private Table updateOrDeleteManagedEntity( final ClassOrInterfaceTypeDetails managedEntity, final Database database) { // Update the attributes of the existing JPA-related annotation final AnnotationMetadata jpaAnnotation = getJpaAnnotation(managedEntity); Validate.validState( jpaAnnotation != null, "Neither @%s nor @%s found on existing DBRE-managed entity %s", ROO_JPA_ACTIVE_RECORD.getSimpleTypeName(), ROO_JPA_ENTITY.getSimpleTypeName(), managedEntity.getName().getFullyQualifiedTypeName()); // Find table in database using 'table' and 'schema' attributes from the // JPA annotation final AnnotationAttributeValue<?> tableAttribute = jpaAnnotation.getAttribute(new JavaSymbolName("table")); final String errMsg = "Unable to maintain database-managed entity " + managedEntity.getName().getFullyQualifiedTypeName() + " because its associated table could not be found"; Validate.notNull(tableAttribute, errMsg); final String tableName = (String) tableAttribute.getValue(); Validate.notBlank(tableName, errMsg); final AnnotationAttributeValue<?> schemaAttribute = jpaAnnotation.getAttribute(new JavaSymbolName("schema")); final String schemaName = schemaAttribute != null ? (String) schemaAttribute.getValue() : null; final Table table = database.getTable(tableName, schemaName); if (table == null) { // Table is missing and probably has been dropped so delete managed // type and its identifier if applicable deleteManagedType(managedEntity, "no database table called '" + tableName + "'"); return null; } table.setIncludeNonPortableAttributes(database.isIncludeNonPortableAttributes()); table.setDisableVersionFields(database.isDisableVersionFields()); table.setDisableGeneratedIdentifiers(database.isDisableGeneratedIdentifiers()); // Update the @RooJpaEntity/@RooJpaActiveRecord attributes final AnnotationMetadataBuilder jpaAnnotationBuilder = new AnnotationMetadataBuilder(jpaAnnotation); final Set<JavaSymbolName> attributesToDeleteIfPresent = new LinkedHashSet<JavaSymbolName>(); manageIdentifier( managedEntity.getName(), jpaAnnotationBuilder, attributesToDeleteIfPresent, table); // Manage versionField attribute final AnnotationAttributeValue<?> versionFieldAttribute = jpaAnnotation.getAttribute(new JavaSymbolName(VERSION_FIELD)); if (versionFieldAttribute == null) { if (hasVersionField(table)) { attributesToDeleteIfPresent.add(new JavaSymbolName(VERSION_FIELD)); } else { jpaAnnotationBuilder.addStringAttribute(VERSION_FIELD, ""); } } else { final String versionFieldValue = (String) versionFieldAttribute.getValue(); if (hasVersionField(table) && (StringUtils.isBlank(versionFieldValue) || VERSION.equals(versionFieldValue))) { attributesToDeleteIfPresent.add(new JavaSymbolName(VERSION_FIELD)); } } final AnnotationAttributeValue<?> sequenceNameFieldAttribute = jpaAnnotation.getAttribute(new JavaSymbolName(SEQUENCE_NAME_FIELD)); if (sequenceNameFieldAttribute == null) { if (!table.isDisableGeneratedIdentifiers()) { attributesToDeleteIfPresent.add(new JavaSymbolName(SEQUENCE_NAME_FIELD)); } else { jpaAnnotationBuilder.addStringAttribute(SEQUENCE_NAME_FIELD, ""); } } else { final String sequenceNameFieldValue = (String) sequenceNameFieldAttribute.getValue(); if (!table.isDisableGeneratedIdentifiers() && ("".equals(sequenceNameFieldValue))) { attributesToDeleteIfPresent.add(new JavaSymbolName(SEQUENCE_NAME_FIELD)); } } // Update the annotation on disk final ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(managedEntity); cidBuilder.updateTypeAnnotation(jpaAnnotationBuilder.build(), attributesToDeleteIfPresent); typeManagementService.createOrUpdateTypeOnDisk(cidBuilder.build()); return table; }