@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)); }
/** * This service is being activated so setup it: * <ul> * <li>Create and open the {@link MetadataDependencyRegistryTracker}</li> * <li>Registers {@link RooJavaType#ROO_CONFIGURABLE} as additional * JavaType that will trigger metadata registration.</li> * </ul> */ @Override protected void activate(final ComponentContext cContext) { context = cContext.getBundleContext(); this.registryTracker = new MetadataDependencyRegistryTracker(context, null, PhysicalTypeIdentifier.getMetadataIdentiferType(), getProvidesType()); this.registryTracker.open(); addMetadataTrigger(ROO_CONFIGURABLE); }
public final String getIdForPhysicalJavaType(final String physicalJavaTypeIdentifier) { Validate.isTrue( MetadataIdentificationUtils.getMetadataClass(physicalJavaTypeIdentifier).equals( MetadataIdentificationUtils.getMetadataClass(PhysicalTypeIdentifier .getMetadataIdentiferType())), "Expected a valid physical Java type instance identifier (not '%s')", physicalJavaTypeIdentifier); final JavaType javaType = PhysicalTypeIdentifier.getJavaType(physicalJavaTypeIdentifier); final LogicalPath path = PhysicalTypeIdentifier.getPath(physicalJavaTypeIdentifier); return createLocalIdentifier(javaType, path); }
public static String getFriendlyName(final String metadataId) { Validate.isTrue(isValid(metadataId), "Invalid metadata id '%s'", metadataId); return getPath(metadataId) + "/" + getJavaType(metadataId); }
public static String createIdentifier(ClassOrInterfaceTypeDetails details) { final LogicalPath logicalPath = PhysicalTypeIdentifier.getPath(details.getDeclaredByMetadataId()); return createIdentifier(details.getType(), logicalPath); }
public void addEnumConstant(final String physicalTypeIdentifier, final JavaSymbolName constantName) { Validate.notBlank(physicalTypeIdentifier, "Type identifier not provided"); Validate.notNull(constantName, "Constant name required"); // Obtain the physical type and itd mutable details final PhysicalTypeMetadata ptm = (PhysicalTypeMetadata) metadataService.get(physicalTypeIdentifier); Validate.notNull(ptm, "Java source code unavailable for type %s", PhysicalTypeIdentifier.getFriendlyName(physicalTypeIdentifier)); final PhysicalTypeDetails ptd = ptm.getMemberHoldingTypeDetails(); Validate.notNull(ptd, "Java source code details unavailable for type %s", PhysicalTypeIdentifier.getFriendlyName(physicalTypeIdentifier)); final ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder((ClassOrInterfaceTypeDetails) ptd); // Ensure it's an enum Validate.isTrue(cidBuilder.getPhysicalTypeCategory() == PhysicalTypeCategory.ENUMERATION, "%s is not an enum", PhysicalTypeIdentifier.getFriendlyName(physicalTypeIdentifier)); cidBuilder.addEnumConstant(constantName); createOrUpdateTypeOnDisk(cidBuilder.build()); }
@Override public JavaType createEntityFactory(JavaType currentEntity) { Validate.notNull(currentEntity, "Entity to produce a data on demand provider for is required"); Validate.isTrue(cid.getPhysicalTypeCategory() == PhysicalTypeCategory.CLASS, "Type %s is not a class", currentEntity.getFullyQualifiedTypeName()); Validate.isTrue(!Modifier.isAbstract(cid.getModifier()), "Type %s is abstract", currentEntity.getFullyQualifiedTypeName()); final AnnotationMetadata entityAnnotation = memberDetails.getAnnotation(ENTITY); Validate.isTrue(entityAnnotation != null, "Type %s must be a JPA entity type", currentEntity.getFullyQualifiedTypeName()); PhysicalTypeIdentifier.createIdentifier(factoryClass, path); if (metadataService.get(declaredByMetadataId) != null) { new ClassOrInterfaceTypeDetailsBuilder(declaredByMetadataId, Modifier.PUBLIC, factoryClass, PhysicalTypeCategory.CLASS); new AnnotationMetadataBuilder(RooJavaType.ROO_JPA_ENTITY_FACTORY); entityFactoryAnnotation.addClassAttribute("entity", entity); cidBuilder.addAnnotation(entityFactoryAnnotation); typeManagementService.createOrUpdateTypeOnDisk(cidBuilder.build());
@Override public void createUnitTest(final JavaType entity) { Validate.notNull(entity, "Class to produce an unit test class for is required"); // Check if provided JavaType is a Repository ClassOrInterfaceTypeDetails cid = typeLocationService.getTypeDetails(entity); Validate.notNull(cid.getAnnotation(RooJavaType.ROO_JPA_ENTITY), "Type must be a Roo JPA Entity type."); // Create JPA DataOnDemand artifacts List<DataOnDemandCreatorProvider> dodCreators = getValidDataOnDemandCreatorsForType(entity); for (DataOnDemandCreatorProvider dodCreator : dodCreators) { dodCreator.createDataOnDemand(entity); } final JavaType name = new JavaType(entity + "Test", entity.getModule()); final String declaredByMetadataId = PhysicalTypeIdentifier.createIdentifier(name, Path.SRC_TEST_JAVA.getModulePathId(entity.getModule())); if (metadataService.get(declaredByMetadataId) != null) { // The file already exists return; } // Add @RooUnitTest to source file AnnotationMetadataBuilder rooUnitTestAnnotation = new AnnotationMetadataBuilder(RooJavaType.ROO_JPA_UNIT_TEST); rooUnitTestAnnotation.addClassAttribute("targetClass", entity); final ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(declaredByMetadataId, Modifier.PUBLIC, name, PhysicalTypeCategory.CLASS); cidBuilder.addAnnotation(rooUnitTestAnnotation); typeManagementService.createOrUpdateTypeOnDisk(cidBuilder.build()); }
Validate.notNull(entity, "Entity to produce a data on demand provider for is required"); Validate.notNull(name, "Name of the new data on demand provider is required"); final LogicalPath path = LogicalPath.getInstance(Path.SRC_TEST_JAVA, name.getModule()); Validate.notNull(path, "Location of the new data on demand provider is required"); projectOperations.addDependency(name.getModule(), VALIDATION_API_DEPENDENCY); final String declaredByMetadataId = PhysicalTypeIdentifier.createIdentifier(name, path); if (metadataService.get(declaredByMetadataId) != null) { return new ClassOrInterfaceTypeDetailsBuilder(declaredByMetadataId).getName(); new ArrayList<AnnotationAttributeValue<?>>(); dodConfig.add(new ClassAttributeValue(new JavaSymbolName("entity"), entity)); annotations.add(new AnnotationMetadataBuilder(RooJavaType.ROO_JPA_DATA_ON_DEMAND, dodConfig)); new ClassOrInterfaceTypeDetailsBuilder(declaredByMetadataId, Modifier.PUBLIC, name, PhysicalTypeCategory.CLASS); cidBuilder.setAnnotations(annotations); final ClassOrInterfaceTypeDetails dodClassCid = cidBuilder.build(); typeManagementService.createOrUpdateTypeOnDisk(dodClassCid); return cid.getName();
Validate.isTrue(reportConfigService.isSpringMvcProject(), "Project must be Spring MVC project"); reportConfigService.addJasperReportsViewResolver(); Validate.isTrue(reportConfigService.isJasperViewsProject(), "WEB-INF/spring/jasper-views.xml must exists"); Validate.notNull(javaType, "Java type required"); if (id == null) { throw new IllegalArgumentException("Cannot locate source for '" + javaType.getFullyQualifiedTypeName() + "'"); + PhysicalTypeIdentifier.getFriendlyName(id)); + PhysicalTypeIdentifier.getFriendlyName(id)); + PhysicalTypeIdentifier.getFriendlyName(id)); ClassOrInterfaceTypeDetails mutableTypeDetails = (ClassOrInterfaceTypeDetails) physicalTypeDetails; .getAnnotationOfType(mutableTypeDetails.getAnnotations(), new JavaType(RooWebScaffold.class.getName())); if (rooWebScaffoldAnnotation == null) { logger.warning("The report can not be created over a Controlloer without " .getAnnotationOfType(mutableTypeDetails.getAnnotations(), new JavaType(GvNIXReports.class.getName())); boolean alreadyAdded = false; if (gvNixReportsAnnotation != null) {
Validate.notNull(fileManager, "FileManager is required"); Validate.notNull(metadataDependencyRegistry, "MetadataDependencyRegistry is required"); Validate.notNull(projectOperations, "ProjectOperations is required"); Validate.isTrue(PhysicalTypeIdentifier.isValid(metadataIdentificationString), "Metadata id '%s' is not valid for this metadata provider", metadataIdentificationString); final String canonicalPath = return null; metadataDependencyRegistry.deregisterDependencies(metadataIdentificationString); if (!fileManager.exists(canonicalPath)) { final JavaType javaType = PhysicalTypeIdentifier.getJavaType(metadataIdentificationString); final ClassOrInterfaceTypeDetails typeDetails = typeParsingService.getTypeAtLocation(canonicalPath, metadataIdentificationString, javaType); if (details.getSuperclass() != null) { final String superclassId = details.getSuperclass().getDeclaredByMetadataId(); metadataDependencyRegistry.registerDependency(superclassId, result.getId()); } else { PhysicalTypeIdentifier.createIdentifier(details.getExtendsTypes().get(0), sourcePath); metadataDependencyRegistry.registerDependency(possibleSuperclass, result.getId());
String targetId = PhysicalTypeIdentifier.createIdentifier(className, LogicalPath.getInstance(Path.SRC_MAIN_JAVA, "")); Validate.notNull(ptd, "Java source code details unavailable for type " + PhysicalTypeIdentifier.getFriendlyName(targetId)); Validate.isInstanceOf(ClassOrInterfaceTypeDetails.class, ptd, "Java source code is immutable for type " + PhysicalTypeIdentifier.getFriendlyName(targetId)); .getDeclaredMethods(); .compareTo(method.toString()) == 0) { Validate.isTrue(!javaParserMethodMetadata.getParameterNames() .contains(parameterName), "There couldn't be two parameters with same name: '" mutableTypeDetails, updatedMethodList); classOrInterfaceTypeDetails .addInnerType(new ClassOrInterfaceTypeDetailsBuilder( mutableTypeDetails.getSuperclass())); updateClass(classOrInterfaceTypeDetails.build());
public void addField(final FieldMetadata field, boolean evict) { Validate.notNull(field, "Field metadata not provided"); ptm = (PhysicalTypeMetadata) metadataService.get(field.getDeclaredByMetadataId()); Validate.notNull(ptm, "Java source code unavailable for type %s", PhysicalTypeIdentifier.getFriendlyName(field.getDeclaredByMetadataId())); final PhysicalTypeDetails ptd = ptm.getMemberHoldingTypeDetails(); Validate.notNull(ptd, "Java source code details unavailable for type %s", PhysicalTypeIdentifier.getFriendlyName(field.getDeclaredByMetadataId())); final ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder((ClassOrInterfaceTypeDetails) ptd); if (annotation.getAnnotationType().getFullyQualifiedTypeName().startsWith("javax.validation")) { jsr303Required = true; break; final LogicalPath path = PhysicalTypeIdentifier.getPath(cidBuilder.getDeclaredByMetadataId()); "validation-api", null)); cidBuilder.addField(field); createOrUpdateTypeOnDisk(cidBuilder.build());
public JavaType getItdJavaType(final ItdMetadataProvider metadataProvider) { Validate.notNull(metadataProvider, "Metadata provider required"); return new JavaType(PhysicalTypeIdentifier.getJavaType(getId()).getFullyQualifiedTypeName() + "_Roo_" + metadataProvider.getItdUniquenessFilenameSuffix()); }
@Override public void focus(final JavaType type) { Validate.notNull(type, "Specify the type to focus on"); final String physicalTypeIdentifier = typeLocationService.getPhysicalTypeIdentifier(type); Validate.notNull(physicalTypeIdentifier, "Cannot locate the type %s", type.getFullyQualifiedTypeName()); final PhysicalTypeMetadata ptm = (PhysicalTypeMetadata) metadataService.get(physicalTypeIdentifier); Validate.notNull(ptm, "Class %s does not exist", PhysicalTypeIdentifier.getFriendlyName(physicalTypeIdentifier)); }
@Override public String getPlural(ClassOrInterfaceTypeDetails cid, Locale locale) { Validate.notNull(cid, "ERROR: You must provide a valid ClassOrInterfaceTypeDetails"); Validate.notNull(locale, "ERROR: You must provide a valid Locale"); final JavaType javaType = cid.getType(); final LogicalPath logicalPath = PhysicalTypeIdentifier.getPath(cid.getDeclaredByMetadataId()); final String pluralMetadataKey = PluralMetadata.createIdentifier(javaType, logicalPath); final PluralMetadata pluralMetadata = (PluralMetadata) getMetadataService().get(pluralMetadataKey); if (pluralMetadata != null) { final String plural = pluralMetadata.getPlural(); if (plural.equalsIgnoreCase(javaType.getSimpleTypeName())) { return plural + "Items"; } else { return plural; } } return getPlural(javaType.getSimpleTypeName(), locale); }
List<JavaSymbolName> paramNames, String body) { Validate.notNull(paramTypes, "Param type mustn't be null"); Validate.notNull(paramNames, "Param name mustn't be null"); String targetId = PhysicalTypeIdentifier.createIdentifier(targetType, LogicalPath.getInstance(Path.SRC_MAIN_JAVA, "")); Validate.notNull(ptm, "Java source class doesn't exists."); Validate.notNull(ptd, "Java source code details unavailable for type " + PhysicalTypeIdentifier.getFriendlyName(targetId)); Validate.isInstanceOf(ClassOrInterfaceTypeDetails.class, ptd, "Java source code is immutable for type " + PhysicalTypeIdentifier.getFriendlyName(targetId)); ClassOrInterfaceTypeDetails mutableTypeDetails = (ClassOrInterfaceTypeDetails) ptd; ClassOrInterfaceTypeDetailsBuilder mutableTypeDetailsBuilder = new ClassOrInterfaceTypeDetailsBuilder( mutableTypeDetails); mutableTypeDetailsBuilder.addMethod(operationMetadata.build()); typeManagementService .createOrUpdateTypeOnDisk(mutableTypeDetailsBuilder.build());
Validate.notNull(projectOperations, "ProjectOperations is required"); final LogicalPath path = PhysicalTypeIdentifier.getPath(field.getDeclaredByMetadataId()); final String moduleNme = path.getModule(); if (projectOperations.isProjectAvailable(moduleNme) if (annotationMetadata.getAnnotationType().equals(TRANSIENT)) { return null; if (fieldType.isCommonCollectionType()) { if (fieldType.getParameters().isEmpty()) { return null; getPersistenceMemberLocator().getIdentifierAccessor(fieldType); if (identifierAccessor != null) { getMetadataDependencyRegistry().registerDependency( identifierAccessor.getDeclaredByMetadataId(), metadataIdentificationString); return identifierAccessor.getMethodName();
Validate.isTrue(!JdkJavaType.isPartOfJavaLang(name.getSimpleTypeName()), "Class name '%s' is part of java.lang", name.getSimpleTypeName()); final String declaredByMetadataId = PhysicalTypeIdentifier.createIdentifier(name, path); final ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(declaredByMetadataId, modifier, name, PhysicalTypeCategory.CLASS); if (!superclass.equals(OBJECT)) { final ClassOrInterfaceTypeDetails superclassClassOrInterfaceTypeDetails = typeLocationService.getTypeDetails(superclass); if (superclassClassOrInterfaceTypeDetails != null) { cidBuilder.setSuperclass(new ClassOrInterfaceTypeDetailsBuilder( superclassClassOrInterfaceTypeDetails)); typeLocationService.getTypeDetails(declaredByMetadataId); if (typeDetails != null) { implementsTypes.addAll(typeDetails.getImplementsTypes()); final List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(); annotations.add(new AnnotationMetadataBuilder(ROO_JAVA_BEAN)); annotations.add(new AnnotationMetadataBuilder(ROO_TO_STRING)); annotations.add(new AnnotationMetadataBuilder(ROO_EQUALS)); annotations.add(new AnnotationMetadataBuilder(ROO_SERIALIZABLE)); cidBuilder.setAnnotations(annotations); typeManagementService.createOrUpdateTypeOnDisk(cidBuilder.build());
public static void addConstructor(final CompilationUnitServices compilationUnitServices, final List<BodyDeclaration> members, final ConstructorMetadata constructor, final Set<JavaSymbolName> typeParameters) { Validate.notNull(compilationUnitServices, "Compilation unit services required"); Validate.notNull(members, "Members required"); Validate.notNull(constructor, "Method required"); d.setName(PhysicalTypeIdentifier.getJavaType(constructor.getDeclaredByMetadataId()) .getSimpleTypeName()); if (constructorParameter.getJavaType().isPrimitive()) { parameterType = JavaParserUtils.getType(constructorParameter.getJavaType()); } else { if (constructorParameter.getJavaType().getParameters().size() > 0) { final List<Type> typeArgs = new ArrayList<Type>(); cit.setTypeArgs(typeArgs);