/** * Constructs a {@link JavaType}. * <p> * The fully qualified type name will be enforced as follows: * <ul> * <li>The rules listed in * {@link JavaSymbolName#assertJavaNameLegal(String)} * <li>First letter of simple type name must be upper-case</li> * </ul> * <p> * A fully qualified type name may include or exclude a package designator. * * @param fullyQualifiedTypeName the name (as per the above rules; * mandatory) * @param enclosingType the type's enclosing type */ public JavaType(final String fullyQualifiedTypeName, final JavaType enclosingType) { this(fullyQualifiedTypeName, enclosingType, 0, DataType.TYPE, null, null, enclosingType .getModule()); }
@Override public JavaType getDataOnDemandConfiguration(String moduleName) { Set<JavaType> dodConfigurationTypes = typeLocationService .findTypesWithAnnotation(RooJavaType.ROO_JPA_DATA_ON_DEMAND_CONFIGURATION); Iterator<JavaType> it = dodConfigurationTypes.iterator(); while (it.hasNext()) { JavaType dodConfigType = it.next(); if (dodConfigType.getModule().equals(moduleName)) { return dodConfigType; } } return null; }
private String getFieldModule(final FieldDetails fieldDetails) { String module = null; if (fieldDetails.getFieldType() != null) { module = fieldDetails.getFieldType().getModule(); } if (fieldDetails instanceof CollectionField) { final CollectionField collectionField = (CollectionField) fieldDetails; module = collectionField.getGenericParameterTypeName().getModule(); } return module; }
public void addModuleDependency(final String moduleName, final JavaType moduleJavaTypeToDependUpon) { if (moduleJavaTypeToDependUpon.getModule() != null) { getProjectOperations() .addModuleDependency(moduleName, moduleJavaTypeToDependUpon.getModule()); } else { ClassOrInterfaceTypeDetails details = getTypeDetails(moduleJavaTypeToDependUpon); if (details != null && details.getName().getModule() != null) { getProjectOperations().addModuleDependency(moduleName, details.getName().getModule()); } } }
/** * Add dependencies between modules if needed * * @param entity * @param relatedRepository * @param relatedService * @param controllerToUpdateOrCreate */ private void addModuleDependencies(JavaType entity, ClassOrInterfaceTypeDetails relatedRepository, JavaType relatedService, ClassOrInterfaceTypeDetails controllerToUpdateOrCreate) { if (projectOperations.isMultimoduleProject()) { // Add service module dependency projectOperations.addModuleDependency(controllerToUpdateOrCreate.getType().getModule(), relatedService.getModule()); // Add repository module dependency projectOperations.addModuleDependency(controllerToUpdateOrCreate.getType().getModule(), relatedRepository.getType().getModule()); // Add model module dependency projectOperations.addModuleDependency(controllerToUpdateOrCreate.getType().getModule(), entity.getModule()); } }
/** * This method check if the provided element is located in an application * module or not * * @param type */ private boolean isLocatedInApplicationModule(JavaType type) { if (type == null) { return false; } else if ("".equals(type.getModule())) { return true; } else { String moduleName = type.getModule(); // Getting all application modules Collection<Pom> modules = getTypeLocationService().getModules(ModuleFeatureName.APPLICATION); for (Pom pom : modules) { if (pom.getModuleName().equals(moduleName)) { return true; } } } return false; }
protected JavaType getCustomRepositoryJavaTypeFor(JavaType repositoryType) { String javaTypeName = repositoryType.getPackage().getFullyQualifiedPackageName().concat(".") .concat(repositoryType.getSimpleTypeName()).concat("Custom"); return new JavaType(javaTypeName, repositoryType.getModule()); }
private JavaType getCollaboratingType(final JavaType entity, final Set<ClassOrInterfaceTypeDetails> entityFactoryClasses) { JavaType dataOnDemand = null; for (ClassOrInterfaceTypeDetails dataOnDemandClass : entityFactoryClasses) { String searchDataOnDemand = entity.getSimpleTypeName().concat("DataOnDemand"); if (dataOnDemandClass.getType().getSimpleTypeName().equals(searchDataOnDemand) && governorTypeDetails.getType().getModule() .equals(dataOnDemandClass.getType().getModule())) { dataOnDemand = dataOnDemandClass.getType(); } } return dataOnDemand; }
@Override public List<String> getModuleNames() { List<String> moduleNames = new ArrayList<String>(); for (ClassOrInterfaceTypeDetails cid : getTypeLocationService() .findClassesOrInterfaceDetailsWithAnnotation( new JavaType("org.springframework.boot.autoconfigure.SpringBootApplication"))) { moduleNames.add(cid.getName().getModule()); } return moduleNames; }
@Override protected ItdTypeDetailsProvidingMetadataItem getMetadata( final String metadataIdentificationString, final JavaType aspectName, final PhysicalTypeMetadata governorPhysicalTypeMetadata, final String itdFilename) { // Get application main class Set<JavaType> applicationTypes = getTypeLocationService().findTypesWithAnnotation(SpringJavaType.SPRING_BOOT_APPLICATION); String repositoryConfigurationModuleName = governorPhysicalTypeMetadata.getType().getModule(); JavaType applicationMainType = null; for (JavaType applicationType : applicationTypes) { if (applicationType.getModule().equals(repositoryConfigurationModuleName)) { applicationMainType = applicationType; } } Validate.notNull(applicationMainType, "Unable to find a main application class on module %s", repositoryConfigurationModuleName); // Check if security is installed in module boolean isSpringletsSecurityEnabled = getProjectOperations() .isFeatureInstalled(applicationMainType.getModule(), "SPRINGLETS_JPA"); return new RepositoryJpaConfigurationMetadata(metadataIdentificationString, aspectName, governorPhysicalTypeMetadata, applicationMainType, isSpringletsSecurityEnabled); }
@Override public void createUnitTest(JavaType type) { // Check if specified type exists in the project String physicalTypeIdentifier = typeLocationService.getPhysicalTypeIdentifier(type); if (physicalTypeIdentifier == null) { throw new IllegalArgumentException(String.format( "The class '%s' doesn't exists in the project. Please, specify an existing class", type)); } // Adding unit test dependencies List<TestCreatorProvider> validTestCreators = getValidTestCreatorsForType(type); if (!validTestCreators.isEmpty()) { addUnitTestDependencies(type.getModule()); } // Creating tests if (validTestCreators.isEmpty()) { throw new IllegalArgumentException( "Unable to find a valid test creator for this type of class. " + "Please, select another type of class to generate the test, such as an entity."); } else { for (TestCreatorProvider creator : validTestCreators) { creator.createUnitTest(type); } } }
@Override public JavaType createDataOnDemand(JavaType entity) { Validate.notNull(entity, "Entity to produce a data on demand provider for is required"); JavaType dodClass = getDataOnDemand(entity); if (dodClass != null) { return dodClass; } // Add plugin to generate test jar addMavenJarPlugin(entity.getModule()); // Create the JavaType for DoD class JavaType name = new JavaType(entity.getPackage().getFullyQualifiedPackageName().concat(".dod.") .concat(entity.getSimpleTypeName()).concat("DataOnDemand"), entity.getModule()); // Obatain test path for the module of the new class final LogicalPath path = LogicalPath.getInstance(Path.SRC_TEST_JAVA, name.getModule()); Validate.notNull(path, "Location of the new data on demand provider is required"); // Create DoD configuration class createDataOnDemandConfiguration(entity.getModule()); // Create entity factories for the given entity and its related entities createEntityFactory(entity); // Create data on demand class return newDataOnDemandClass(entity, name); }
public JavaType withoutParameters() { return new JavaType(getFullyQualifiedTypeName(), getArray(), DataType.TYPE, getArgName(), null, getModule()); } }
private void registerDependencyModulesOfFinder( final PhysicalTypeMetadata governorPhysicalTypeMetadata, MethodMetadata finder) { // Add dependencies between modules List<JavaType> types = new ArrayList<JavaType>(); types.add(finder.getReturnType()); types.addAll(finder.getReturnType().getParameters()); for (AnnotatedJavaType parameter : finder.getParameterTypes()) { types.add(parameter.getJavaType()); types.addAll(parameter.getJavaType().getParameters()); } for (JavaType parameter : types) { getTypeLocationService().addModuleDependency( governorPhysicalTypeMetadata.getType().getModule(), parameter); } }
@Override public boolean isInstalledInModule(String moduleName) { Pom module = getProjectOperations().getPomFromModuleName(moduleName); for (JavaType javaType : getTypeLocationService().findTypesWithAnnotation( RooJavaType.ROO_WEB_MVC_CONFIGURATION)) { if (javaType.getModule().equals(moduleName) && module.hasDependencyExcludingVersion(new Dependency("org.springframework.boot", "spring-boot-starter-web", null))) { return true; } } return false; }
@Override public void deleteEntity(JavaType entity) { final String entityFilePathIdentifier = getPathResolver().getCanonicalPath(entity.getModule(), Path.SRC_MAIN_JAVA, entity); if (getFileManager().exists(entityFilePathIdentifier)) { getFileManager().delete(entityFilePathIdentifier); } }
/** * Returns the non-primitive type that represent this type if it is primitive. Otherwise, returns itself. * @return */ public JavaType toObjectType() { if (isPrimitive()) { return new JavaType(getFullyQualifiedTypeName(), getArray(), DataType.TYPE, getArgName(), getParameters(), getModule()); } return this; }
@Override protected ItdTypeDetailsProvidingMetadataItem getMetadata( final String metadataIdentificationString, final JavaType aspectName, final PhysicalTypeMetadata governorPhysicalTypeMetadata, final String itdFilename) { final DtoAnnotationValues annotationValues = new DtoAnnotationValues(governorPhysicalTypeMetadata); // Get all DTO fields ClassOrInterfaceTypeDetails cid = governorPhysicalTypeMetadata.getMemberHoldingTypeDetails(); List<FieldMetadata> fields = getMemberDetailsScanner().getMemberDetails(this.getClass().getName(), cid).getFields(); // Add dependency between modules for (FieldMetadata field : fields) { getTypeLocationService().addModuleDependency(cid.getName().getModule(), field.getFieldType()); } return new DtoMetadata(metadataIdentificationString, aspectName, governorPhysicalTypeMetadata, annotationValues, fields); }
@Override public void newEmbeddableClass(final JavaType name, final boolean serializable) { Validate.notNull(name, "Embeddable name required"); final String declaredByMetadataId = PhysicalTypeIdentifier.createIdentifier(name, getPathResolver().getFocusedPath(Path.SRC_MAIN_JAVA)); final List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(Arrays.asList(new AnnotationMetadataBuilder( ROO_JAVA_BEAN), new AnnotationMetadataBuilder(ROO_TO_STRING), new AnnotationMetadataBuilder(EMBEDDABLE))); if (serializable) { annotations.add(new AnnotationMetadataBuilder(ROO_SERIALIZABLE)); } final int modifier = Modifier.PUBLIC; final ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(declaredByMetadataId, modifier, name, PhysicalTypeCategory.CLASS); cidBuilder.setAnnotations(annotations); getTypeManagementService().createOrUpdateTypeOnDisk(cidBuilder.build()); getProjectOperations().addDependency(name.getModule(), new Dependency("org.springframework.boot", "spring-boot-starter-data-jpa", null)); }
@Override protected ItdTypeDetailsProvidingMetadataItem getMetadata( final String metadataIdentificationString, final JavaType aspectName, final PhysicalTypeMetadata governorPhysicalTypeMetadata, final String itdFilename) { final EntityProjectionAnnotationValues annotationValues = new EntityProjectionAnnotationValues(governorPhysicalTypeMetadata); // Get CID from governor ClassOrInterfaceTypeDetails cid = governorPhysicalTypeMetadata.getMemberHoldingTypeDetails(); // Get all projection fields from annotation String[] fieldsString = annotationValues.getFields(); List<FieldMetadata> fields = buildFieldMetadataFromAnnotation(fieldsString, cid); // Add dependency between modules for (FieldMetadata field : fields) { getTypeLocationService().addModuleDependency(cid.getName().getModule(), field.getFieldType()); } return new EntityProjectionMetadata(metadataIdentificationString, aspectName, governorPhysicalTypeMetadata, annotationValues, fields); }