@Override public void restResource( final JavaType type, final boolean hide, final String path, final String rel) { final ClassOrInterfaceTypeDetails typeDetails = typeLocationService.getTypeDetails(type); Validate.notNull(typeDetails, "The repository specified, '" + type + "'doesn't exist"); final AnnotationMetadataBuilder annotationBuilder = new AnnotationMetadataBuilder(REST_RESOURCE); if (hide) { annotationBuilder.addBooleanAttribute("exported", false); } if (!StringUtils.isEmpty(path)) { annotationBuilder.addStringAttribute("path", path); } if (!StringUtils.isEmpty(rel)) { annotationBuilder.addStringAttribute("rel", rel); } final ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(typeDetails); if (MemberFindingUtils.getAnnotationOfType(typeDetails.getAnnotations(), REST_RESOURCE) != null) { cidBuilder.removeAnnotation(REST_RESOURCE); } cidBuilder.addAnnotation(annotationBuilder); typeManagementService.createOrUpdateTypeOnDisk(cidBuilder.build()); }
/** * 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; }
/** * Locates the entity manager field that should be used. * * <p>If a parent is defined, it must provide the field. * * <p>We generally expect the field to be named "entityManager" and be of type * javax.persistence.EntityManager. We also require it to be public or protected, and annotated * with @PersistenceContext. If there is an existing field which doesn't meet these latter * requirements, we add an underscore prefix to the "entityManager" name and try again, until such * time as we come up with a unique name that either meets the requirements or the name is not * used and we will create it. * * @return the entity manager field (never returns null) */ public FieldMetadata getEntityManagerField() { if (parent != null) { // The parent is required to guarantee this is available return parent.getEntityManagerField(); } // Need to locate it ourself int index = -1; while (true) { // Compute the required field name index++; final JavaSymbolName fieldSymbolName = new JavaSymbolName(StringUtils.repeat("_", index) + "entityManager"); final FieldMetadata candidate = governorTypeDetails.getField(fieldSymbolName); if (candidate != null) { // Verify if candidate is suitable if (!Modifier.isPublic(candidate.getModifier()) && !Modifier.isProtected(candidate.getModifier()) && (Modifier.TRANSIENT != candidate.getModifier())) { // Candidate is not public and not protected and not simply a transient field (in which // case subclasses // will see the inherited field), so any subsequent subclasses won't be able to see it. // Give up! continue; } if (!candidate.getFieldType().equals(ENTITY_MANAGER)) { // Candidate isn't an EntityManager, so give up continue; } if (MemberFindingUtils.getAnnotationOfType(candidate.getAnnotations(), PERSISTENCE_CONTEXT) == null) { // Candidate doesn't have a PersistenceContext annotation, so give up continue; } // If we got this far, we found a valid candidate return candidate; } // Candidate not found, so let's create one final List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); final AnnotationMetadataBuilder annotationBuilder = new AnnotationMetadataBuilder(PERSISTENCE_CONTEXT); if (StringUtils.hasText(crudAnnotationValues.getPersistenceUnit())) { annotationBuilder.addStringAttribute("unitName", crudAnnotationValues.getPersistenceUnit()); } annotations.add(annotationBuilder); final FieldMetadataBuilder fieldBuilder = new FieldMetadataBuilder( getId(), Modifier.TRANSIENT, annotations, fieldSymbolName, ENTITY_MANAGER); return fieldBuilder.build(); } }
private void addTransactionalAnnotation( final List<AnnotationMetadataBuilder> annotations, final boolean isPersistMethod) { final AnnotationMetadataBuilder transactionalBuilder = new AnnotationMetadataBuilder(TRANSACTIONAL); if (StringUtils.hasText(crudAnnotationValues.getTransactionManager())) { transactionalBuilder.addStringAttribute( "value", crudAnnotationValues.getTransactionManager()); } if (isGaeEnabled && isPersistMethod) { transactionalBuilder.addEnumAttribute( "propagation", new EnumDetails(PROPAGATION, new JavaSymbolName("REQUIRES_NEW"))); } annotations.add(transactionalBuilder); }
@Override public void resourceString( final JavaType type, final String name, final JavaSymbolName fieldName, final String value) { final ClassOrInterfaceTypeDetails typeDetails = typeLocationService.getTypeDetails(type); Validate.notNull(typeDetails, "The type specified, '" + type + "' doesn't exist"); final DocumentBuilder builder = newDocumentBuilder(); final String valuesPath = pathResolver.getFocusedIdentifier(Path.ROOT, VALUES_PATH + SEP + STRINGS + XML_EXTENSION); InputStream inputStream = null; Document document = null; try { inputStream = fileManager.getInputStream(valuesPath); document = builder.parse(inputStream); } catch (final Exception e) { LOGGER.severe("Error reading resource XML: " + e.getMessage()); } finally { IOUtils.closeQuietly(inputStream); } if (document != null) { final Element root = document.getDocumentElement(); final Element stringElem = XmlUtils.createTextElement(document, "string", value); final String id = StringUtils.isEmpty(name) ? fieldName.getSymbolName() : name; stringElem.setAttribute("name", id); root.appendChild(stringElem); fileManager.createOrUpdateTextFileIfRequired( valuesPath, XmlUtils.nodeToString(document), true); } final String physicalTypeIdentifier = typeDetails.getDeclaredByMetadataId(); final List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); final AnnotationMetadataBuilder annotationBuilder = new AnnotationMetadataBuilder(ROO_STRING); if (!StringUtils.isEmpty(name)) { annotationBuilder.addStringAttribute("value", name); } annotations.add(annotationBuilder); final FieldMetadataBuilder fieldBuilder = new FieldMetadataBuilder(physicalTypeIdentifier, 0, annotations, fieldName, STRING); typeManagementService.addField(fieldBuilder.build()); }
@Override public void activity( final JavaType name, final String layout, final boolean main, final boolean noTitle, final boolean fullscreen) { if (noTitle) { Validate.isTrue(fullscreen == false, "Options 'noTitle' and 'fullscreen' are mutex"); } if (fullscreen) { Validate.isTrue(noTitle == false, "Options 'noTitle' and 'fullscreen' are mutex"); } if (!StringUtils.isEmpty(layout)) { final String layoutPath = pathResolver.getFocusedIdentifier(Path.ROOT, LAYOUT_PATH + SEP + layout + XML_EXTENSION); if (!fileManager.exists(layoutPath)) { LOGGER.info("Layout '" + layout + "' does not exist"); layout(layout, Dimension.FILL_PARENT, Dimension.FILL_PARENT, Orientation.VERTICAL); } } final List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); final AnnotationMetadataBuilder activityAnnotationBuilder = new AnnotationMetadataBuilder(ROO_ACTIVITY); if (!StringUtils.isEmpty(layout)) { activityAnnotationBuilder.addStringAttribute("value", layout); } if (noTitle) { activityAnnotationBuilder.addBooleanAttribute(RooActivity.NO_TITLE_ATTRIBUTE, noTitle); } if (fullscreen) { activityAnnotationBuilder.addBooleanAttribute(RooActivity.FULLSCREEN_ATTRIBUTE, fullscreen); } annotations.add(activityAnnotationBuilder); jpaOperations.newEntity(name, false, ANDROID_ACTIVITY, annotations); androidTypeService.addActvity( projectOperations.getFocusedModuleName(), name.getFullyQualifiedTypeName(), main); }
@Override public void fragment(final JavaType name, final String layout, final boolean support) { if (!StringUtils.isEmpty(layout)) { final String layoutPath = pathResolver.getFocusedIdentifier(Path.ROOT, LAYOUT_PATH + SEP + layout + XML_EXTENSION); if (!fileManager.exists(layoutPath)) { LOGGER.info("Layout '" + layout + "' does not exist"); layout(layout, Dimension.FILL_PARENT, Dimension.FILL_PARENT, Orientation.VERTICAL); } } final List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); final AnnotationMetadataBuilder activityAnnotationBuilder = new AnnotationMetadataBuilder(ROO_FRAGMENT); if (!StringUtils.isEmpty(layout)) { activityAnnotationBuilder.addStringAttribute("value", layout); } annotations.add(activityAnnotationBuilder); jpaOperations.newEntity( name, false, support ? ANDROID_SUPPORT_FRAGMENT : ANDROID_FRAGMENT, annotations); }
/** @return a test for the persist method, if available and requested (may return null) */ private MethodMetadataBuilder getRemoveMethodTest( final MemberTypeAdditions removeMethod, final MemberTypeAdditions findMethod, final MemberTypeAdditions flushMethod, final MethodMetadata identifierAccessorMethod) { if (!annotationValues.isRemove() || removeMethod == null || findMethod == null || identifierAccessorMethod == null) { // User does not want this method or one of its core dependencies return null; } // Prepare method signature JavaSymbolName methodName = new JavaSymbolName("test" + StringUtils.capitalize(removeMethod.getMethodName())); if (governorHasMethod(methodName)) { return null; } builder.getImportRegistrationResolver().addImport(identifierAccessorMethod.getReturnType()); List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(new AnnotationMetadataBuilder(TEST)); if (isGaeSupported) { AnnotationMetadataBuilder transactionalBuilder = new AnnotationMetadataBuilder(TRANSACTIONAL); if (StringUtils.hasText(transactionManager) && !"transactionManager".equals(transactionManager)) { transactionalBuilder.addStringAttribute("value", transactionManager); } transactionalBuilder.addEnumAttribute( "propagation", new EnumDetails(PROPAGATION, new JavaSymbolName("SUPPORTS"))); annotations.add(transactionalBuilder); } final String entityName = annotationValues.getEntity().getSimpleTypeName(); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine( entityName + " obj = dod." + dataOnDemandMetadata.getRandomPersistentEntityMethod().getMethodName().getSymbolName() + "();"); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Data on demand for '" + entityName + "' failed to initialize correctly\", obj);"); bodyBuilder.appendFormalLine( identifierAccessorMethod.getReturnType().getSimpleTypeName() + " id = obj." + identifierAccessorMethod.getMethodName().getSymbolName() + "();"); bodyBuilder.appendFormalLine( "Assert.assertNotNull(\"Data on demand for '" + entityName + "' failed to provide an identifier\", id);"); bodyBuilder.appendFormalLine("obj = " + findMethod.getMethodCall() + ";"); bodyBuilder.appendFormalLine(removeMethod.getMethodCall() + ";"); if (flushMethod != null) { bodyBuilder.appendFormalLine(flushMethod.getMethodCall() + ";"); flushMethod.copyAdditionsTo(builder, governorTypeDetails); } bodyBuilder.appendFormalLine( "Assert.assertNull(\"Failed to remove '" + entityName + "' with identifier '\" + id + \"'\", " + findMethod.getMethodCall() + ");"); removeMethod.copyAdditionsTo(builder, governorTypeDetails); findMethod.copyAdditionsTo(builder, governorTypeDetails); MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), Modifier.PUBLIC, methodName, JavaType.VOID_PRIMITIVE, bodyBuilder); methodBuilder.setAnnotations(annotations); return methodBuilder; }
/** Adds the JUnit and Spring type level annotations if needed */ private void addRequiredIntegrationTestClassIntroductions(final JavaType dodGovernor) { // Add an @RunWith(SpringJunit4ClassRunner) annotation to the type, if // the user did not define it on the governor directly if (MemberFindingUtils.getAnnotationOfType(governorTypeDetails.getAnnotations(), RUN_WITH) == null) { AnnotationMetadataBuilder runWithBuilder = new AnnotationMetadataBuilder(RUN_WITH); runWithBuilder.addClassAttribute( "value", "org.springframework.test.context.junit4.SpringJUnit4ClassRunner"); builder.addAnnotation(runWithBuilder); } // Add an @ContextConfiguration("classpath:/applicationContext.xml") // annotation to the type, if the user did not define it on the governor // directly if (MemberFindingUtils.getAnnotationOfType( governorTypeDetails.getAnnotations(), CONTEXT_CONFIGURATION) == null) { AnnotationMetadataBuilder contextConfigurationBuilder = new AnnotationMetadataBuilder(CONTEXT_CONFIGURATION); contextConfigurationBuilder.addStringAttribute( "locations", "classpath:/META-INF/spring/applicationContext*.xml"); builder.addAnnotation(contextConfigurationBuilder); } // Add an @Transactional, if the user did not define it on the governor // directly if (annotationValues.isTransactional() && MemberFindingUtils.getAnnotationOfType( governorTypeDetails.getAnnotations(), TRANSACTIONAL) == null) { AnnotationMetadataBuilder transactionalBuilder = new AnnotationMetadataBuilder(TRANSACTIONAL); if (StringUtils.hasText(transactionManager) && !"transactionManager".equals(transactionManager)) { transactionalBuilder.addStringAttribute("value", transactionManager); } builder.addAnnotation(transactionalBuilder); } // Add the data on demand field if the user did not define it on the // governor directly FieldMetadata field = governorTypeDetails.getField(new JavaSymbolName("dod")); if (field != null) { Assert.isTrue( field.getFieldType().equals(dodGovernor), "Field 'dod' on '" + destination.getFullyQualifiedTypeName() + "' must be of type '" + dodGovernor.getFullyQualifiedTypeName() + "'"); Assert.notNull( MemberFindingUtils.getAnnotationOfType(field.getAnnotations(), AUTOWIRED), "Field 'dod' on '" + destination.getFullyQualifiedTypeName() + "' must be annotated with @Autowired"); } else { // Add the field via the ITD List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(new AnnotationMetadataBuilder(AUTOWIRED)); FieldMetadataBuilder fieldBuilder = new FieldMetadataBuilder( getId(), Modifier.PRIVATE, annotations, new JavaSymbolName("dod"), dodGovernor); builder.addField(fieldBuilder); } builder.getImportRegistrationResolver().addImport(ASSERT); }
@Override public void installLanguage(final I18n language, final boolean useAsDefault, final Pom module) { // Check if provided module match with application modules features Validate.isTrue( getTypeLocationService().hasModuleFeature(module, ModuleFeatureName.APPLICATION), "ERROR: Provided module doesn't match with application modules features. " + "Execute this operation again and provide a valid application module."); Validate.notNull(language, "ERROR: You should provide a valid language code."); if (language.getLocale() == null) { LOGGER.warning("ERROR: Provided language is not valid."); return; } final LogicalPath resourcesPath = LogicalPath.getInstance(Path.SRC_MAIN_RESOURCES, module.getModuleName()); final String targetDirectory = getPathResolver().getIdentifier(resourcesPath, ""); // Getting message.properties file String messageBundle = ""; if (language.getLocale().equals(Locale.ENGLISH)) { messageBundle = targetDirectory + "messages.properties"; } else { messageBundle = targetDirectory .concat("messages_") .concat(language.getLocale().getLanguage().concat(".properties")); } if (!getFileManager().exists(messageBundle)) { InputStream inputStream = null; OutputStream outputStream = null; try { inputStream = language.getMessageBundle(); outputStream = getFileManager().createFile(messageBundle).getOutputStream(); IOUtils.copy(inputStream, outputStream); } catch (final Exception e) { throw new IllegalStateException( "Encountered an error during copying of message bundle MVC JSP addon.", e); } finally { IOUtils.closeQuietly(inputStream); IOUtils.closeQuietly(outputStream); } } // Install flag final String flagGraphic = targetDirectory .concat("static/public/img/") .concat(language.getLocale().getLanguage()) .concat(".png"); if (!getFileManager().exists(flagGraphic)) { InputStream inputStream = null; OutputStream outputStream = null; try { inputStream = language.getFlagGraphic(); outputStream = getFileManager().createFile(flagGraphic).getOutputStream(); IOUtils.copy(inputStream, outputStream); } catch (final Exception e) { throw new IllegalStateException( "Encountered an error during copying of flag graphic for MVC JSP addon.", e); } finally { IOUtils.closeQuietly(inputStream); IOUtils.closeQuietly(outputStream); } } // Update @WebMvcConfiguration annotation defining defaultLanguage // attribute if (useAsDefault) { // Obtain all existing configuration classes annotated with // @RooWebMvcConfiguration Set<ClassOrInterfaceTypeDetails> configurationClasses = getTypeLocationService() .findClassesOrInterfaceDetailsWithAnnotation(RooJavaType.ROO_WEB_MVC_CONFIGURATION); for (ClassOrInterfaceTypeDetails configurationClass : configurationClasses) { // If configuration class is located in the provided module if (configurationClass.getType().getModule().equals(module.getModuleName())) { ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(configurationClass); AnnotationMetadataBuilder annotation = cidBuilder.getDeclaredTypeAnnotation(RooJavaType.ROO_WEB_MVC_CONFIGURATION); annotation.addStringAttribute("defaultLanguage", language.getLocale().getLanguage()); // Update configuration class getTypeManagementService().createOrUpdateTypeOnDisk(cidBuilder.build()); } } LOGGER.log( Level.INFO, String.format( "INFO: Default language of your project has been changed to %s.", language.getLanguage())); } // Get all controllers and update its message bundles Set<ClassOrInterfaceTypeDetails> controllers = getTypeLocationService() .findClassesOrInterfaceDetailsWithAnnotation(RooJavaType.ROO_CONTROLLER); for (ClassOrInterfaceTypeDetails controller : controllers) { getMetadataService().evictAndGet(ControllerMetadata.createIdentifier(controller)); } // Add application property getApplicationConfigService() .addProperty( module.getModuleName(), "spring.messages.fallback-to-system-locale", "false", "", true); }
@Override public void view( final JavaType type, final String viewName, final String identifier, final JavaSymbolName fieldName, final Dimension height, final Dimension width) { final ClassOrInterfaceTypeDetails typeDetails = typeLocationService.getTypeDetails(type); Validate.notNull(typeDetails, "The type specified, '" + type + "'doesn't exist"); final JavaType viewType = new JavaType(viewName.contains(".") ? viewName : WIDGET_PACKAGE + "." + viewName); final String layout = RequestFactoryUtils.getStringAnnotationValue(typeDetails, ROO_ACTIVITY, "value", ""); if (!StringUtils.isEmpty(layout)) { final DocumentBuilder builder = newDocumentBuilder(); final String layoutPath = pathResolver.getFocusedIdentifier(Path.ROOT, LAYOUT_PATH + SEP + layout + XML_EXTENSION); InputStream inputStream = null; Document document = null; try { inputStream = fileManager.getInputStream(layoutPath); document = builder.parse(inputStream); } catch (final Exception e) { LOGGER.severe("Error reading layout XML: " + e.getMessage()); } finally { IOUtils.closeQuietly(inputStream); } if (document != null) { final Element root = document.getDocumentElement(); final Element viewElem = document.createElement(viewType.getSimpleTypeName()); final String id = StringUtils.isEmpty(identifier) ? fieldName.getSymbolName() : identifier; viewElem.setAttribute("android:id", ID_PREFIX + id); viewElem.setAttribute("android:layout_height", height.value()); viewElem.setAttribute("android:layout_width", width.value()); root.appendChild(viewElem); fileManager.createOrUpdateTextFileIfRequired( layoutPath, XmlUtils.nodeToString(document), true); } } final String physicalTypeIdentifier = typeDetails.getDeclaredByMetadataId(); final List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); final AnnotationMetadataBuilder annotationBuilder = new AnnotationMetadataBuilder(ROO_VIEW); if (!StringUtils.isEmpty(identifier)) { annotationBuilder.addStringAttribute("value", identifier); } annotations.add(annotationBuilder); final FieldMetadataBuilder fieldBuilder = new FieldMetadataBuilder(physicalTypeIdentifier, 0, annotations, fieldName, viewType); typeManagementService.addField(fieldBuilder.build()); }
public MetadataItem get(String metadataIdentificationString) { ProjectMetadata projectMetadata = projectOperations.getProjectMetadata(); if (projectMetadata == null) { return null; } ClassOrInterfaceTypeDetails proxy = getGovernor(metadataIdentificationString); if (proxy == null) { return null; } AnnotationMetadata proxyAnnotation = GwtUtils.getFirstAnnotation(proxy, GwtUtils.PROXY_ANNOTATIONS); if (proxyAnnotation == null) { return null; } String locatorType = GwtUtils.getStringValue(proxyAnnotation.getAttribute("locator")); if (!StringUtils.hasText(locatorType)) { return null; } ClassOrInterfaceTypeDetails entity = gwtTypeService.lookupEntityFromProxy(proxy); if (entity == null) { return null; } MethodMetadata idAccessor = persistenceMemberLocator.getIdentifierAccessor(entity.getName()); MethodMetadata versionAccessor = persistenceMemberLocator.getVersionAccessor(entity.getName()); if (idAccessor == null || versionAccessor == null) { return null; } final JavaType idType = GwtUtils.convertPrimitiveType(idAccessor.getReturnType(), true); String locatorIdentifier = PhysicalTypeIdentifier.createIdentifier(new JavaType(locatorType)); ClassOrInterfaceTypeDetailsBuilder locatorBuilder = new ClassOrInterfaceTypeDetailsBuilder(locatorIdentifier); AnnotationMetadataBuilder annotationMetadataBuilder = new AnnotationMetadataBuilder(RooJavaType.ROO_GWT_LOCATOR); annotationMetadataBuilder.addStringAttribute( "value", entity.getName().getFullyQualifiedTypeName()); locatorBuilder.addAnnotation(annotationMetadataBuilder); annotationMetadataBuilder = new AnnotationMetadataBuilder(SpringJavaType.COMPONENT); locatorBuilder.addAnnotation(annotationMetadataBuilder); locatorBuilder.setName(new JavaType(locatorType)); locatorBuilder.setModifier(Modifier.PUBLIC); locatorBuilder.setPhysicalTypeCategory(PhysicalTypeCategory.CLASS); locatorBuilder.addExtendsTypes( new JavaType( GwtUtils.LOCATOR.getFullyQualifiedTypeName(), 0, DataType.TYPE, null, Arrays.asList(entity.getName(), idType))); locatorBuilder.addMethod(getCreateMethod(locatorIdentifier, entity.getName())); locatorBuilder.addMethod( getFindMethod(locatorBuilder, locatorIdentifier, entity.getName(), idType)); locatorBuilder.addMethod(getDomainTypeMethod(locatorIdentifier, entity.getName())); locatorBuilder.addMethod(getIdMethod(locatorIdentifier, entity.getName(), idAccessor)); locatorBuilder.addMethod(getIdTypeMethod(locatorIdentifier, entity.getName(), idType)); locatorBuilder.addMethod( getVersionMethod(locatorIdentifier, entity.getName(), versionAccessor)); typeManagementService.createOrUpdateTypeOnDisk(locatorBuilder.build()); return null; }
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; }