/**
* Add the {@link AuditOverride} annotations.
*
* @param property the property being processed
* @param propertyData the Envers auditing data for this property
*/
private void addPropertyAuditingOverrides(XProperty property, PropertyAuditingData propertyData) {
final AuditOverride annotationOverride = property.getAnnotation(AuditOverride.class);
if (annotationOverride != null) {
propertyData.addAuditingOverride(annotationOverride);
}
final AuditOverrides annotationOverrides = property.getAnnotation(AuditOverrides.class);
if (annotationOverrides != null) {
propertyData.addAuditingOverrides(annotationOverrides);
}
}
/**
* Checks if a property is audited and if yes, fills all of its data.
*
* @param property Property to check.
* @param propertyData Property data, on which to set this property's modification store.
* @param accessType Access type for the property.
* @return False if this property is not audited.
*/
private boolean fillPropertyData(
XProperty property,
PropertyAuditingData propertyData,
String accessType,
Audited allClassAudited) {
// check if a property is declared as not audited to exclude it
// useful if a class is audited but some properties should be excluded
final NotAudited unVer = property.getAnnotation(NotAudited.class);
if ((unVer != null && !overriddenAuditedProperties.contains(property))
|| overriddenNotAuditedProperties.contains(property)) {
return false;
} else {
// if the optimistic locking field has to be unversioned and the current property
// is the optimistic locking field, don't audit it
if (globalCfg.isDoNotAuditOptimisticLockingField()) {
final Version jpaVer = property.getAnnotation(Version.class);
if (jpaVer != null) {
return false;
}
}
}
if (!this.checkAudited(property, propertyData, allClassAudited)) {
return false;
}
final String propertyName = propertyNamePrefix + property.getName();
propertyData.setName(propertyName);
propertyData.setModifiedFlagName(
MetadataTools.getModifiedFlagPropertyName(propertyName, globalCfg.getModifiedFlagSuffix()));
propertyData.setBeanName(property.getName());
propertyData.setAccessType(accessType);
addPropertyJoinTables(property, propertyData);
addPropertyAuditingOverrides(property, propertyData);
if (!processPropertyAuditingOverrides(property, propertyData)) {
// not audited due to AuditOverride annotation
return false;
}
addPropertyMapKey(property, propertyData);
setPropertyAuditMappedBy(property, propertyData);
setPropertyRelationMappedBy(property, propertyData);
return true;
}
private void addPropertyJoinTables(XProperty property, PropertyAuditingData propertyData) {
// first set the join table based on the AuditJoinTable annotation
final AuditJoinTable joinTable = property.getAnnotation(AuditJoinTable.class);
if (joinTable != null) {
propertyData.setJoinTable(joinTable);
} else {
propertyData.setJoinTable(DEFAULT_AUDIT_JOIN_TABLE);
}
}
private void setPropertyAuditMappedBy(XProperty property, PropertyAuditingData propertyData) {
final AuditMappedBy auditMappedBy = property.getAnnotation(AuditMappedBy.class);
if (auditMappedBy != null) {
propertyData.setAuditMappedBy(auditMappedBy.mappedBy());
if (!"".equals(auditMappedBy.positionMappedBy())) {
propertyData.setPositionMappedBy(auditMappedBy.positionMappedBy());
}
}
}
public static Float getBoost(XProperty member, Annotation fieldAnn) {
float computedBoost = 1.0f;
Boost boostAnn = member.getAnnotation(Boost.class);
if (boostAnn != null) {
computedBoost = boostAnn.value();
}
if (fieldAnn != null) {
float boost;
if (fieldAnn instanceof org.hibernate.search.annotations.Field) {
boost = ((org.hibernate.search.annotations.Field) fieldAnn).boost().value();
} else if (fieldAnn instanceof Spatial) {
boost = ((Spatial) fieldAnn).boost().value();
} else {
raiseAssertionOnIncorrectAnnotation(fieldAnn);
boost = 0; // never reached
}
computedBoost *= boost;
}
return computedBoost;
}
protected boolean checkAudited(
XProperty property, PropertyAuditingData propertyData, Audited allClassAudited) {
// Checking if this property is explicitly audited or if all properties are.
Audited aud =
(property.isAnnotationPresent(Audited.class))
? property.getAnnotation(Audited.class)
: allClassAudited;
if (aud == null
&& overriddenAuditedProperties.contains(property)
&& !overriddenNotAuditedProperties.contains(property)) {
// Assigning @Audited defaults. If anyone needs to customize those values in the future,
// appropriate fields shall be added to @AuditOverride annotation.
aud = DEFAULT_AUDITED;
}
if (aud != null) {
propertyData.setStore(aud.modStore());
propertyData.setRelationTargetAuditMode(aud.targetAuditMode());
propertyData.setUsingModifiedFlag(checkUsingModifiedFlag(aud));
return true;
} else {
return false;
}
}
private void searchForRevisionInfoCfgInProperties(
XClass clazz,
ReflectionManager reflectionManager,
MutableBoolean revisionNumberFound,
MutableBoolean revisionTimestampFound,
MutableBoolean modifiedEntityNamesFound,
String accessType) {
for (XProperty property : clazz.getDeclaredProperties(accessType)) {
RevisionNumber revisionNumber = property.getAnnotation(RevisionNumber.class);
RevisionTimestamp revisionTimestamp = property.getAnnotation(RevisionTimestamp.class);
ModifiedEntityNames modifiedEntityNames = property.getAnnotation(ModifiedEntityNames.class);
if (revisionNumber != null) {
if (revisionNumberFound.isSet()) {
throw new MappingException("Only one property may be annotated with @RevisionNumber!");
}
XClass revisionNumberClass = property.getType();
if (reflectionManager.equals(revisionNumberClass, Integer.class)
|| reflectionManager.equals(revisionNumberClass, Integer.TYPE)) {
revisionInfoIdData =
new PropertyData(property.getName(), property.getName(), accessType, null);
revisionNumberFound.set();
} else if (reflectionManager.equals(revisionNumberClass, Long.class)
|| reflectionManager.equals(revisionNumberClass, Long.TYPE)) {
revisionInfoIdData =
new PropertyData(property.getName(), property.getName(), accessType, null);
revisionNumberFound.set();
// The default is integer
revisionPropType = "long";
} else {
throw new MappingException(
"The field annotated with @RevisionNumber must be of type "
+ "int, Integer, long or Long");
}
// Getting the @Column definition of the revision number property, to later use that info to
// generate the same mapping for the relation from an audit table's revision number to the
// revision entity revision number.
Column revisionPropColumn = property.getAnnotation(Column.class);
if (revisionPropColumn != null) {
revisionPropSqlType = revisionPropColumn.columnDefinition();
}
}
if (revisionTimestamp != null) {
if (revisionTimestampFound.isSet()) {
throw new MappingException("Only one property may be annotated with @RevisionTimestamp!");
}
XClass revisionTimestampClass = property.getType();
if (reflectionManager.equals(revisionTimestampClass, Long.class)
|| reflectionManager.equals(revisionTimestampClass, Long.TYPE)
|| reflectionManager.equals(revisionTimestampClass, Date.class)
|| reflectionManager.equals(revisionTimestampClass, java.sql.Date.class)) {
revisionInfoTimestampData =
new PropertyData(property.getName(), property.getName(), accessType, null);
revisionTimestampFound.set();
} else {
throw new MappingException(
"The field annotated with @RevisionTimestamp must be of type "
+ "long, Long, java.util.Date or java.sql.Date");
}
}
if (modifiedEntityNames != null) {
if (modifiedEntityNamesFound.isSet()) {
throw new MappingException(
"Only one property may be annotated with @ModifiedEntityNames!");
}
XClass modifiedEntityNamesClass = property.getType();
if (reflectionManager.equals(modifiedEntityNamesClass, Set.class)
&& reflectionManager.equals(property.getElementClass(), String.class)) {
modifiedEntityNamesData =
new PropertyData(property.getName(), property.getName(), accessType, null);
modifiedEntityNamesFound.set();
} else {
throw new MappingException(
"The field annotated with @ModifiedEntityNames must be of Set<String> type.");
}
}
}
}
private void addPropertyMapKey(XProperty property, PropertyAuditingData propertyData) {
final MapKey mapKey = property.getAnnotation(MapKey.class);
if (mapKey != null) {
propertyData.setMapKey(mapKey.name());
}
}
private void setPropertyRelationMappedBy(XProperty property, PropertyAuditingData propertyData) {
final OneToMany oneToMany = property.getAnnotation(OneToMany.class);
if (oneToMany != null && !"".equals(oneToMany.mappedBy())) {
propertyData.setRelationMappedBy(oneToMany.mappedBy());
}
}
