use of org.springframework.roo.classpath.details.annotations.NestedAnnotationAttributeValue in project spring-roo by spring-projects.
the class DbreMetadata method getJoinColumnsAnnotation.
private AnnotationMetadataBuilder getJoinColumnsAnnotation(final Set<Reference> references, final JavaType fieldType) {
final List<NestedAnnotationAttributeValue> arrayValues = new ArrayList<NestedAnnotationAttributeValue>();
// Nullable attribute will have same value for each
// If some column not required, all JoinColumn will be nullable
boolean nullable = false;
for (final Reference reference : references) {
if (!reference.getLocalColumn().isRequired()) {
nullable = true;
}
}
for (final Reference reference : references) {
final AnnotationMetadataBuilder joinColumnAnnotation = getJoinColumnAnnotation(reference, true, fieldType, nullable);
arrayValues.add(new NestedAnnotationAttributeValue(new JavaSymbolName(VALUE), joinColumnAnnotation.build()));
}
final List<AnnotationAttributeValue<?>> attributes = new ArrayList<AnnotationAttributeValue<?>>();
attributes.add(new ArrayAttributeValue<NestedAnnotationAttributeValue>(new JavaSymbolName(VALUE), arrayValues));
return new AnnotationMetadataBuilder(JOIN_COLUMNS, attributes);
}
use of org.springframework.roo.classpath.details.annotations.NestedAnnotationAttributeValue in project spring-roo by spring-projects.
the class FinderOperationsImpl method installFinder.
public void installFinder(final JavaType entity, final JavaSymbolName finderName, JavaType formBean, JavaType returnType) {
Validate.notNull(entity, "ERROR: Entity type required to generate finder.");
Validate.notNull(finderName, "ERROR: Finder name required to generate finder.");
final String id = getTypeLocationService().getPhysicalTypeIdentifier(entity);
if (id == null) {
LOGGER.warning("Cannot locate source for '" + entity.getFullyQualifiedTypeName() + "'");
return;
}
// Check if provided entity is annotated with @RooJpaEntity
ClassOrInterfaceTypeDetails entityDetails = getTypeLocationService().getTypeDetails(entity);
AnnotationMetadata entityAnnotation = entityDetails.getAnnotation(RooJavaType.ROO_JPA_ENTITY);
Validate.notNull(entityAnnotation, "ERROR: Provided entity must be annotated with @RooJpaEntity");
// Getting repository that manages current entity
ClassOrInterfaceTypeDetails repository = getRepositoryJpaLocator().getRepository(entity);
// Entity must have a repository that manages it, if not, shows an error
Validate.notNull(repository, "ERROR: You must generate a repository to the provided entity before to add new finder. You could use 'repository jpa' commands.");
// Check if provided formBean contains the field names and types indicated as finder params
if (formBean != null) {
MemberDetails entityMemberDetails = getMemberDetailsScanner().getMemberDetails(this.getClass().getName(), getTypeLocationService().getTypeDetails(entity));
PartTree finderPartTree = new PartTree(finderName.getSymbolName(), entityMemberDetails);
checkDtoFieldsForFinder(getTypeLocationService().getTypeDetails(formBean), finderPartTree, repository.getType());
}
// Get repository annotation
AnnotationMetadata repositoryAnnotation = repository.getAnnotation(RooJavaType.ROO_REPOSITORY_JPA);
AnnotationMetadataBuilder repositoryAnnotationBuilder = new AnnotationMetadataBuilder(repositoryAnnotation);
// Create list that will include finders to add
List<AnnotationAttributeValue<?>> finders = new ArrayList<AnnotationAttributeValue<?>>();
// Check if new finder name to be included already exists in @RooRepositoryJpa annotation
AnnotationAttributeValue<?> currentFinders = repositoryAnnotation.getAttribute("finders");
if (currentFinders != null) {
List<?> values = (List<?>) currentFinders.getValue();
Iterator<?> it = values.iterator();
while (it.hasNext()) {
NestedAnnotationAttributeValue finder = (NestedAnnotationAttributeValue) it.next();
if (finder.getValue() != null && finder.getValue().getAttribute("value") != null) {
if (finder.getValue().getAttribute("value").getValue().equals(finderName.getSymbolName())) {
LOGGER.log(Level.WARNING, String.format("ERROR: Finder '%s' already exists on entity '%s'", finderName.getSymbolName(), entity.getSimpleTypeName()));
return;
}
finders.add(finder);
}
}
}
// Create @RooFinder
AnnotationMetadataBuilder singleFinderAnnotation = new AnnotationMetadataBuilder(RooJavaType.ROO_FINDER);
// Add finder attribute
singleFinderAnnotation.addStringAttribute("value", finderName.getSymbolName());
// Add returnType attribute
singleFinderAnnotation.addClassAttribute("returnType", returnType);
// Prevent errors validating if the return type contains a valid module
if (returnType.getModule() != null) {
getProjectOperations().addModuleDependency(repository.getName().getModule(), returnType.getModule());
}
// Add formBean attribute
if (formBean != null) {
singleFinderAnnotation.addClassAttribute("formBean", formBean);
getProjectOperations().addModuleDependency(repository.getName().getModule(), formBean.getModule());
}
NestedAnnotationAttributeValue newFinder = new NestedAnnotationAttributeValue(new JavaSymbolName("value"), singleFinderAnnotation.build());
// If not exists current finder, include it
finders.add(newFinder);
// Add finder list to currentFinders
ArrayAttributeValue<AnnotationAttributeValue<?>> newFinders = new ArrayAttributeValue<AnnotationAttributeValue<?>>(new JavaSymbolName("finders"), finders);
// Include finder name to finders attribute
repositoryAnnotationBuilder.addAttribute(newFinders);
// Update @RooRepositoryJpa annotation
final ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(repository);
// Update annotation
cidBuilder.updateTypeAnnotation(repositoryAnnotationBuilder);
// Save changes on disk
getTypeManagementService().createOrUpdateTypeOnDisk(cidBuilder.build());
}
use of org.springframework.roo.classpath.details.annotations.NestedAnnotationAttributeValue in project spring-roo by spring-projects.
the class RepositoryJpaMetadataProviderImpl method getMetadata.
@Override
protected ItdTypeDetailsProvidingMetadataItem getMetadata(final String metadataIdentificationString, final JavaType aspectName, final PhysicalTypeMetadata governorPhysicalTypeMetadata, final String itdFilename) {
final RepositoryJpaAnnotationValues annotationValues = new RepositoryJpaAnnotationValues(governorPhysicalTypeMetadata);
final JavaType domainType = annotationValues.getEntity();
// XXX clear entitiesDetails by security
entitiesDetails.clear();
// Remember that this entity JavaType matches up with this metadata
// identification string
// Start by clearing any previous association
final JavaType oldEntity = repositoryMidToDomainTypeMap.get(metadataIdentificationString);
if (oldEntity != null) {
domainTypeToRepositoryMidMap.remove(oldEntity);
}
domainTypeToRepositoryMidMap.put(domainType, metadataIdentificationString);
repositoryMidToDomainTypeMap.put(metadataIdentificationString, domainType);
// Getting associated entity
JavaType entity = annotationValues.getEntity();
ClassOrInterfaceTypeDetails entityDetails = getTypeLocationService().getTypeDetails(entity);
MemberDetails entityMemberDetails = getMemberDetailsScanner().getMemberDetails(this.getClass().getName(), entityDetails);
final String entityMetadataId = JpaEntityMetadata.createIdentifier(entityDetails);
final JpaEntityMetadata entityMetadata = getMetadataService().get(entityMetadataId);
if (entityMetadata == null) {
return null;
}
// Getting java bean metadata
final String javaBeanMetadataKey = JavaBeanMetadata.createIdentifier(entityDetails);
// Register dependency between repositoryMetadata and jpaEntityMetadata
registerDependency(entityMetadataId, metadataIdentificationString);
// Create dependency between repository and java bean annotation
registerDependency(javaBeanMetadataKey, metadataIdentificationString);
// Check if related entity is setted as readOnly
JavaType readOnlyRepository = null;
if (entityMetadata.isReadOnly()) {
// Getting ReadOnlyRepository interface annotated with
// @RooReadOnlyRepository
Set<ClassOrInterfaceTypeDetails> readOnlyRepositories = getTypeLocationService().findClassesOrInterfaceDetailsWithAnnotation(ROO_READ_ONLY_REPOSITORY);
Validate.notEmpty(readOnlyRepositories, "ERROR: You should define a ReadOnlyRepository interface annotated with @RooReadOnlyRepository to be able to generate repositories of readOnly entities.");
Iterator<ClassOrInterfaceTypeDetails> it = readOnlyRepositories.iterator();
while (it.hasNext()) {
ClassOrInterfaceTypeDetails readOnlyRepositoryDetails = it.next();
readOnlyRepository = readOnlyRepositoryDetails.getType();
break;
}
}
List<JavaType> repositoryCustomList = new ArrayList<JavaType>();
// Getting RepositoryCustom interface annotated with
// @RooJpaRepositoryCustom
Set<ClassOrInterfaceTypeDetails> customRepositories = getTypeLocationService().findClassesOrInterfaceDetailsWithAnnotation(ROO_REPOSITORY_JPA_CUSTOM);
Iterator<ClassOrInterfaceTypeDetails> customRepositoriesIt = customRepositories.iterator();
while (customRepositoriesIt.hasNext()) {
ClassOrInterfaceTypeDetails customRepository = customRepositoriesIt.next();
AnnotationMetadata annotation = customRepository.getAnnotation(ROO_REPOSITORY_JPA_CUSTOM);
if (annotation.getAttribute("entity").getValue().equals(entity)) {
repositoryCustomList.add(customRepository.getType());
}
}
Validate.notEmpty(repositoryCustomList, "Can't find any interface annotated with @%s(entity=%s)", ROO_REPOSITORY_JPA_CUSTOM.getSimpleTypeName(), entity.getSimpleTypeName());
Validate.isTrue(repositoryCustomList.size() == 1, "More than one interface annotated with @%s(entity=%s): %s", ROO_REPOSITORY_JPA_CUSTOM.getSimpleTypeName(), entity.getSimpleTypeName(), StringUtils.join(repositoryCustomList, ","));
JavaType defaultReturnType;
final JavaType annotationDefaultReturnType = annotationValues.getDefaultReturnType();
// Get and check defaultReturnType
if (annotationDefaultReturnType == null || annotationDefaultReturnType.equals(JavaType.CLASS) || annotationDefaultReturnType.equals(entity)) {
defaultReturnType = entity;
} else {
// Validate that defaultReturnValue is projection of current entity
ClassOrInterfaceTypeDetails returnTypeCid = getTypeLocationService().getTypeDetails(annotationDefaultReturnType);
AnnotationMetadata projectionAnnotation = returnTypeCid.getAnnotation(RooJavaType.ROO_ENTITY_PROJECTION);
Validate.notNull(projectionAnnotation, "ERROR: %s defined on %s.@%s.defaultReturnType must be annotated with @%s annotation", annotationDefaultReturnType, governorPhysicalTypeMetadata.getType(), RooJavaType.ROO_REPOSITORY_JPA, RooJavaType.ROO_ENTITY_PROJECTION);
Validate.isTrue(entity.equals(projectionAnnotation.getAttribute("entity").getValue()), "ERROR: %s defined on %s.@%s.defaultReturnType must be annotated with @%s annotation and match the 'entity' attribute value", annotationDefaultReturnType, governorPhysicalTypeMetadata.getType(), RooJavaType.ROO_REPOSITORY_JPA, RooJavaType.ROO_ENTITY_PROJECTION);
defaultReturnType = annotationDefaultReturnType;
}
// Get field which entity is field part
List<Pair<FieldMetadata, RelationInfo>> relationsAsChild = getJpaOperations().getFieldChildPartOfRelation(entityDetails);
// Get Annotation
ClassOrInterfaceTypeDetails cid = governorPhysicalTypeMetadata.getMemberHoldingTypeDetails();
AnnotationMetadata repositoryAnnotation = cid.getAnnotation(ROO_REPOSITORY_JPA);
// Create list of finder to add
List<FinderMethod> findersToAdd = new ArrayList<FinderMethod>();
// Create list of finder to add in RespositoryCustom
List<Pair<FinderMethod, PartTree>> findersToAddInCustom = new ArrayList<Pair<FinderMethod, PartTree>>();
Map<JavaType, ClassOrInterfaceTypeDetails> detailsCache = new HashMap<JavaType, ClassOrInterfaceTypeDetails>();
List<String> declaredFinderNames = new ArrayList<String>();
RooFinder[] findersAnnValue = annotationValues.getFinders();
// Get finders attributes
AnnotationAttributeValue<?> currentFinders = repositoryAnnotation.getAttribute("finders");
if (currentFinders != null) {
List<?> values = (List<?>) currentFinders.getValue();
Iterator<?> valuesIt = values.iterator();
while (valuesIt.hasNext()) {
NestedAnnotationAttributeValue finderAnnotation = (NestedAnnotationAttributeValue) valuesIt.next();
if (finderAnnotation.getValue() != null && finderAnnotation.getValue().getAttribute("value") != null) {
// Get finder name
String finderName = null;
if (finderAnnotation.getValue().getAttribute("value").getValue() instanceof String) {
finderName = (String) finderAnnotation.getValue().getAttribute("value").getValue();
}
Validate.notNull(finderName, "'finder' attribute in @RooFinder must be a String");
declaredFinderNames.add(finderName);
// Get finder return type
JavaType returnType = getNestedAttributeValue(finderAnnotation, "returnType");
JavaType finderReturnType;
if (returnType == null || JavaType.CLASS.equals(returnType)) {
finderReturnType = defaultReturnType;
returnType = null;
} else {
finderReturnType = returnType;
}
// Get finder return type
JavaType formBean = getNestedAttributeValue(finderAnnotation, "formBean");
boolean isDeclaredFormBean = false;
if (JavaType.CLASS.equals(formBean)) {
formBean = null;
}
// Create FinderMethods
PartTree finder = new PartTree(finderName, entityMemberDetails, this, finderReturnType);
Validate.notNull(finder, String.format("ERROR: '%s' is not a valid finder. Use autocomplete feature (TAB or CTRL + Space) to include finder that follows Spring Data nomenclature.", finderName));
FinderMethod finderMethod = new FinderMethod(finder);
// Add dependencies between modules
List<JavaType> types = new ArrayList<JavaType>();
types.add(finder.getReturnType());
types.addAll(finder.getReturnType().getParameters());
for (FinderParameter parameter : finder.getParameters()) {
types.add(parameter.getType());
types.addAll(parameter.getType().getParameters());
}
for (JavaType parameter : types) {
getTypeLocationService().addModuleDependency(governorPhysicalTypeMetadata.getType().getModule(), parameter);
}
if (formBean == null && (returnType == null || entity.equals(returnType))) {
// Add to finder methods list
findersToAdd.add(finderMethod);
} else {
// RepositoryCustom classes.
if (returnType != null && !returnType.equals(entity)) {
ClassOrInterfaceTypeDetails returnTypeDetails = getDetailsFor(returnType, detailsCache);
Validate.isTrue(returnTypeDetails != null && returnTypeDetails.getAnnotation(RooJavaType.ROO_ENTITY_PROJECTION) != null, "ERROR: finder '%s' declared 'returnType' (%s) is not annotated with @%s annotation", finderName, returnType.getSimpleTypeName(), RooJavaType.ROO_ENTITY_PROJECTION.getSimpleTypeName());
}
Validate.notNull(formBean, "ERROR: finder '%s' requires 'formBean' value if 'defaultReturnType' is defined", finderName);
ClassOrInterfaceTypeDetails formBeanDetails = getTypeLocationService().getTypeDetails(formBean);
Validate.isTrue(formBeanDetails != null && formBeanDetails.getAnnotation(RooJavaType.ROO_DTO) != null, "ERROR: finder '%s' declared 'formBean' (%s) is not annotated with @%s annotation", finderName, formBean.getSimpleTypeName(), RooJavaType.ROO_ENTITY_PROJECTION.getSimpleTypeName());
checkDtoFieldsForFinder(formBeanDetails, finder, governorPhysicalTypeMetadata.getType());
if (returnType == null) {
returnType = entity;
}
finderMethod = new FinderMethod(returnType, new JavaSymbolName(finderName), Arrays.asList(new FinderParameter(formBean, new JavaSymbolName(StringUtils.uncapitalize(formBean.getSimpleTypeName())))));
findersToAddInCustom.add(Pair.of(finderMethod, finder));
}
}
}
}
return new RepositoryJpaMetadata(metadataIdentificationString, aspectName, governorPhysicalTypeMetadata, annotationValues, entityMetadata, readOnlyRepository, repositoryCustomList.get(0), defaultReturnType, relationsAsChild, findersToAdd, findersToAddInCustom, declaredFinderNames);
}
use of org.springframework.roo.classpath.details.annotations.NestedAnnotationAttributeValue in project spring-roo by spring-projects.
the class SecurityAuthorizationsMetadataProviderImpl method getMetadata.
@Override
protected ItdTypeDetailsProvidingMetadataItem getMetadata(final String metadataIdentificationString, final JavaType aspectName, final PhysicalTypeMetadata governorPhysicalTypeMetadata, final String itdFilename) {
// Getting the annotated entity type
JavaType annotatedService = governorPhysicalTypeMetadata.getType();
// Getting the service details
MemberDetails serviceDetails = getMemberDetailsScanner().getMemberDetails(getClass().getName(), getTypeLocationService().getTypeDetails(annotatedService));
Map<MethodMetadata, String> preAuthorizationMethods = new LinkedHashMap<MethodMetadata, String>();
// Get methods defined in each annotation @RooSecurityAuthorization
AnnotationMetadata annotationAuthorizations = serviceDetails.getAnnotation(RooJavaType.ROO_SECURITY_AUTHORIZATIONS);
AnnotationAttributeValue<?> attributeAuthorizations = annotationAuthorizations.getAttribute("authorizations");
List<?> values = (List<?>) attributeAuthorizations.getValue();
if (values != null && !values.isEmpty()) {
Iterator<?> valuesIt = values.iterator();
while (valuesIt.hasNext()) {
NestedAnnotationAttributeValue authorizationAnnotation = (NestedAnnotationAttributeValue) valuesIt.next();
// Get attributes from the annotation @RooSecurityAuthorization
String methodName = (String) authorizationAnnotation.getValue().getAttribute("method").getValue();
List<?> methodParameters = (List<?>) authorizationAnnotation.getValue().getAttribute("parameters").getValue();
List<MethodMetadata> methods = serviceDetails.getMethods(new JavaSymbolName(methodName));
for (MethodMetadata method : methods) {
// check the parameters to get corresponding method
if (checkParameters(method, methodParameters)) {
String roles = null;
if (authorizationAnnotation.getValue().getAttribute("roles") != null) {
roles = (String) authorizationAnnotation.getValue().getAttribute("roles").getValue();
}
String usernames = null;
if (authorizationAnnotation.getValue().getAttribute("usernames") != null) {
usernames = (String) authorizationAnnotation.getValue().getAttribute("usernames").getValue();
}
// Create the content based on defined roles and
// usernames to include it in the security annotation
String secAnnotationValue = getSecurityOperations().getSpringSecurityAnnotationValue(roles, usernames);
preAuthorizationMethods.put(method, secAnnotationValue);
break;
}
}
}
}
return new SecurityAuthorizationsMetadata(metadataIdentificationString, aspectName, governorPhysicalTypeMetadata, preAuthorizationMethods);
}
Aggregations