/**
* Creates a new DBRE-managed entity from the given table
*
* @param javaType the name of the entity to be created (required)
* @param table the table from which to create the entity (required)
* @param activeRecord whether to create "active record" CRUD methods in the new entity
* @return the newly created entity
*/
private ClassOrInterfaceTypeDetails createNewManagedEntityFromTable(
final JavaType javaType, final Table table, final boolean activeRecord) {
// Create type annotations for new entity
final List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>();
annotations.add(new AnnotationMetadataBuilder(ROO_JAVA_BEAN));
annotations.add(new AnnotationMetadataBuilder(ROO_TO_STRING));
// Find primary key from db metadata and add identifier attributes to
// @RooJpaEntity
final AnnotationMetadataBuilder jpaAnnotationBuilder =
new AnnotationMetadataBuilder(activeRecord ? ROO_JPA_ACTIVE_RECORD : ROO_JPA_ENTITY);
manageIdentifier(javaType, jpaAnnotationBuilder, new HashSet<JavaSymbolName>(), table);
if (!hasVersionField(table)) {
jpaAnnotationBuilder.addStringAttribute(VERSION_FIELD, "");
}
if (table.isDisableGeneratedIdentifiers()) {
jpaAnnotationBuilder.addStringAttribute(SEQUENCE_NAME_FIELD, "");
}
jpaAnnotationBuilder.addStringAttribute("table", table.getName());
if (!DbreModelService.NO_SCHEMA_REQUIRED.equals(table.getSchema().getName())) {
jpaAnnotationBuilder.addStringAttribute("schema", table.getSchema().getName());
}
annotations.add(jpaAnnotationBuilder);
// Add @RooDbManaged
annotations.add(getRooDbManagedAnnotation());
final JavaType superclass = OBJECT;
final List<JavaType> extendsTypes = new ArrayList<JavaType>();
extendsTypes.add(superclass);
// Create entity class
final String declaredByMetadataId =
PhysicalTypeIdentifier.createIdentifier(
javaType, projectOperations.getPathResolver().getFocusedPath(Path.SRC_MAIN_JAVA));
final ClassOrInterfaceTypeDetailsBuilder cidBuilder =
new ClassOrInterfaceTypeDetailsBuilder(
declaredByMetadataId, Modifier.PUBLIC, javaType, PhysicalTypeCategory.CLASS);
cidBuilder.setExtendsTypes(extendsTypes);
cidBuilder.setAnnotations(annotations);
final ClassOrInterfaceTypeDetails entity = cidBuilder.build();
typeManagementService.createOrUpdateTypeOnDisk(entity);
shell.flash(
Level.FINE,
"Created " + javaType.getFullyQualifiedTypeName(),
DbreDatabaseListenerImpl.class.getName());
shell.flash(Level.FINE, "", DbreDatabaseListenerImpl.class.getName());
return entity;
}
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;
}