public List<BusinessObject> getReferencedBusinessObjectsByComposition() { List<BusinessObject> refs = new ArrayList<>(); for (Field field : fields) { if (isACompositionField(field)) { refs.add(((RelationField) field).getReference()); } } return refs; }
@Override public String toString() { return new ToStringBuilder(this, ToStringStyle.SHORT_PREFIX_STYLE).append("name", getName()).append("type", type).append("reference", reference) .toString(); }
private boolean isACompositionField(Field field) { return field instanceof RelationField && Type.COMPOSITION == ((RelationField) field).getType(); }
private static RelationField aRelationField(final String name, final BusinessObject reference) { final RelationField relationField = new RelationField(); relationField.setName(name); relationField.setReference(reference); return relationField; }
@Override protected ValidationStatus validate(BusinessObjectModel bom) { ValidationStatus validationStatus = new ValidationStatus(); for (BusinessObject bo : bom.getBusinessObjects()) { List<Field> boFields = bo.getFields(); for (Field boField : boFields) { if (boField instanceof RelationField) { RelationField relationField = (RelationField) boField; String fieldReferenceQualifiedName = relationField.getReference().getQualifiedName(); String boQualifiedName = bo.getQualifiedName(); if (relationField.getType() == AGGREGATION && fieldReferenceQualifiedName.equals(boQualifiedName) && relationField.isCollection()) { validationStatus.addError(MULTIPLE_AGGREGATION_RELATION_TO_ITSELF, "The object " + boQualifiedName + " is referencing itself in a multiple aggregation relation.", Collections.singletonMap(StatusContext.BUSINESS_OBJECT_NAME_KEY, boQualifiedName)); } } } } return validationStatus; } }
public void annotateRelationField(final JDefinedClass entityClass, final RelationField field, final JFieldVar fieldVar) { JAnnotationUse relation = null; if (field.isCollection()) { relation = annotateMultipleReference(entityClass, field, fieldVar); } else { relation = annotateSingleReference(entityClass,field, fieldVar); } if (field.isLazy()) { relation.param("fetch", FetchType.LAZY); codeGenerator.addAnnotation(fieldVar, JsonIgnore.class); } else { relation.param("fetch", FetchType.EAGER); } if (field.getType() == Type.COMPOSITION) { relation.param("cascade", CascadeType.ALL); } else if (field.getType() == Type.AGGREGATION) { relation.param("cascade", CascadeType.MERGE); } }
private JAnnotationUse annotateSingleReference(JDefinedClass entityClass, final RelationField field, final JFieldVar fieldVar) { JAnnotationUse relation; if (field.getType() == Type.AGGREGATION) { relation = codeGenerator.addAnnotation(fieldVar, ManyToOne.class); } else { relation = codeGenerator.addAnnotation(fieldVar, OneToOne.class); relation.param("orphanRemoval", true); } addJoinColumn(fieldVar, field.getName()); relation.param("optional", field.isNullable()); foreignKeyAnnotator.annotateForeignKeyName(entityClass, fieldVar, field); return relation; }
final RelationField country = new RelationField(); country.setType(RelationField.Type.AGGREGATION); country.setFetchType(RelationField.FetchType.LAZY); country.setName("country"); country.setCollection(Boolean.FALSE); country.setNullable(Boolean.TRUE); country.setReference(countryBO); final RelationField addresses = new RelationField(); addresses.setType(RelationField.Type.AGGREGATION); addresses.setFetchType(RelationField.FetchType.EAGER); addresses.setName("addresses"); addresses.setCollection(Boolean.TRUE); addresses.setNullable(Boolean.TRUE); addresses.setReference(addressBO); final RelationField address = new RelationField(); address.setType(RelationField.Type.AGGREGATION); address.setFetchType(RelationField.FetchType.LAZY); address.setName("address"); address.setCollection(Boolean.FALSE); address.setNullable(Boolean.TRUE); address.setReference(addressBO); final RelationField dog = new RelationField(); dog.setType(RelationField.Type.COMPOSITION); dog.setFetchType(RelationField.FetchType.EAGER); dog.setName("dog"); dog.setCollection(Boolean.FALSE);
@Override public Query createQueryForLazyField(BusinessObject businessObject, RelationField relationField) { checkObjectIsNotNull(relationField, "relationField cannot be null"); final String name = createQueryNameForLazyField(businessObject, relationField); final String content = createQueryContentForLazyField(businessObject.getQualifiedName(), relationField); final Query q = new Query(name, content, relationField.getReference().getQualifiedName()); if (relationField.isCollection()) { q.setReturnType(List.class.getName()); } q.addQueryParameter(Field.PERSISTENCE_ID, Long.class.getName()); return q; }
private void addJoinTable(final JDefinedClass entityClass, final RelationField field, final JFieldVar fieldVar) { final JAnnotationUse joinTable = codeGenerator.addAnnotation(fieldVar, JoinTable.class); joinTable.param("name", getJoinTableName(entityClass.name(), field.getName())); final JAnnotationArrayMember joinColumns = joinTable.paramArray("joinColumns"); final JAnnotationUse nameQueryAnnotation = joinColumns.annotate(JoinColumn.class); nameQueryAnnotation.param("name", getJoinColumnName(entityClass.name())); final JAnnotationArrayMember inverseJoinColumns = joinTable.paramArray("inverseJoinColumns"); final JAnnotationUse a = inverseJoinColumns.annotate(JoinColumn.class); a.param("name", getJoinColumnName(field.getReference().getSimpleName())); }
public static List<Query> createProvidedQueriesForLazyField(final BusinessObjectModel bom, final BusinessObject bo) { final List<Query> queries = new ArrayList<>(); for (QueryGenerator queryGenerator : getQueryGenerators()) { for (final BusinessObject businessObject : bom.getBusinessObjects()) { for (final Field f : businessObject.getFields()) { if (f instanceof RelationField && ((RelationField) f).isLazy()) { if (((RelationField) f).getReference().equals(bo)) { final Query query = queryGenerator.createQueryForLazyField(businessObject, (RelationField) f); if (query != null) { queries.add(query); } } } } } } return queries; }
if (field instanceof RelationField) { RelationField relationField = (RelationField) field; if (relationField.getType() == AGGREGATION) { aggregatedBusinessObjects.add(relationField.getReference());
public void addAccessors(final JDefinedClass entityClass, final JFieldVar fieldVar, final Field field) { if (isCollectionField(field)) { codeGenerator.addListSetter(entityClass, fieldVar); } else { codeGenerator.addSetter(entityClass, fieldVar); } final JMethod getter = codeGenerator.addGetter(entityClass, fieldVar); if (field instanceof RelationField && ((RelationField) field).isLazy()) { getter.annotate(LazyLoaded.class); } }
@Override public Query createQueryForLazyField(BusinessObject businessObject, RelationField relationField) { if (relationField.isCollection()) { return super.createQueryForLazyField(businessObject, relationField); } return null; }
public RelationFieldBuilder lazy() { ((RelationField) field).setFetchType(LAZY); return this; }
public RelationFieldBuilder referencing(final BusinessObject bo) { ((RelationField) field).setReference(bo); return this; }
public RelationFieldBuilder() { super(new RelationField()); }
@Override protected ValidationStatus validate(BusinessObjectModel bom) { ValidationStatus validationStatus = new ValidationStatus(); for (BusinessObject bo : bom.getBusinessObjects()) { List<Field> boFields = bo.getFields(); for (Field boField : boFields) { if (boField instanceof RelationField) { RelationField relationField = (RelationField) boField; String fieldReferenceQualifiedName = relationField.getReference().getQualifiedName(); String boQualifiedName = bo.getQualifiedName(); if (relationField.getType() == AGGREGATION && fieldReferenceQualifiedName.equals(boQualifiedName) && relationField.isCollection()) { validationStatus.addError(MULTIPLE_AGGREGATION_RELATION_TO_ITSELF, "The object " + boQualifiedName + " is referencing itself in a multiple aggregation relation.", Collections.singletonMap(StatusContext.BUSINESS_OBJECT_NAME_KEY, boQualifiedName)); } } } } return validationStatus; } }
public void annotateRelationField(final JDefinedClass entityClass, final RelationField field, final JFieldVar fieldVar) { JAnnotationUse relation = null; if (field.isCollection()) { relation = annotateMultipleReference(entityClass, field, fieldVar); } else { relation = annotateSingleReference(entityClass,field, fieldVar); } if (field.isLazy()) { relation.param("fetch", FetchType.LAZY); codeGenerator.addAnnotation(fieldVar, JsonIgnore.class); } else { relation.param("fetch", FetchType.EAGER); } if (field.getType() == Type.COMPOSITION) { relation.param("cascade", CascadeType.ALL); } else if (field.getType() == Type.AGGREGATION) { relation.param("cascade", CascadeType.MERGE); } }
private JAnnotationUse annotateSingleReference(JDefinedClass entityClass, final RelationField field, final JFieldVar fieldVar) { JAnnotationUse relation; if (field.getType() == Type.AGGREGATION) { relation = codeGenerator.addAnnotation(fieldVar, ManyToOne.class); } else { relation = codeGenerator.addAnnotation(fieldVar, OneToOne.class); relation.param("orphanRemoval", true); } addJoinColumn(fieldVar, field.getName()); relation.param("optional", field.isNullable()); foreignKeyAnnotator.annotateForeignKeyName(entityClass, fieldVar, field); return relation; }