use of io.jans.orm.exception.MappingException in project jans by JanssenProject.
the class CouchbaseEntryManager method authenticate.
@Override
public <T> boolean authenticate(String baseDN, Class<T> entryClass, String userName, String password) {
if (StringHelper.isEmptyString(baseDN)) {
throw new MappingException("Base DN to find entries is null");
}
// Check entry class
checkEntryClass(entryClass, false);
String[] objectClasses = getTypeObjectClasses(entryClass);
List<PropertyAnnotation> propertiesAnnotations = getEntryPropertyAnnotations(entryClass);
// Find entries
Filter searchFilter = Filter.createEqualityFilter(Filter.createLowercaseFilter(CouchbaseOperationService.UID), StringHelper.toLowerCase(userName));
if (objectClasses.length > 0) {
searchFilter = addObjectClassFilter(searchFilter, objectClasses);
}
// Prepare properties types to allow build filter properly
Map<String, PropertyAnnotation> propertiesAnnotationsMap = prepareEntryPropertiesTypes(entryClass, propertiesAnnotations);
ConvertedExpression convertedExpression;
try {
convertedExpression = toCouchbaseFilter(searchFilter, propertiesAnnotationsMap);
} catch (SearchException ex) {
throw new EntryPersistenceException(String.format("Failed to convert filter %s to expression", searchFilter));
}
try {
PagedResult<JsonObject> searchResult = searchImpl(toCouchbaseKey(baseDN).getKey(), getScanConsistency(convertedExpression), convertedExpression.expression(), SearchScope.SUB, CouchbaseOperationService.UID_ARRAY, null, null, SearchReturnDataType.SEARCH, 0, 1, 1);
if ((searchResult == null) || (searchResult.getEntriesCount() != 1)) {
return false;
}
String bindDn = searchResult.getEntries().get(0).getString(CouchbaseOperationService.DN);
return authenticate(bindDn, password);
} catch (SearchException ex) {
throw new AuthenticationException(String.format("Failed to find user DN: %s", userName), ex);
} catch (Exception ex) {
throw new AuthenticationException(String.format("Failed to authenticate user: %s", userName), ex);
}
}
use of io.jans.orm.exception.MappingException in project jans by JanssenProject.
the class BaseEntryManager method getListItem.
private Object getListItem(String propertyName, Setter propertyNameSetter, Setter propertyValueSetter, Setter entryPropertyMultivaluedSetter, Class<?> classType, AttributeData attribute) {
if (attribute == null) {
return null;
}
Object result;
try {
result = ReflectHelper.createObjectByDefaultConstructor(classType);
} catch (Exception ex) {
throw new MappingException(String.format("Entry %s should has default constructor", classType));
}
propertyNameSetter.set(result, attribute.getName());
setPropertyValue(propertyName, propertyValueSetter, result, attribute, false);
if ((entryPropertyMultivaluedSetter != null) && (attribute.getMultiValued() != null)) {
entryPropertyMultivaluedSetter.set(result, attribute.getMultiValued());
}
return result;
}
use of io.jans.orm.exception.MappingException in project jans by JanssenProject.
the class BaseEntryManager method createEntities.
protected <T> List<T> createEntities(Class<T> entryClass, List<PropertyAnnotation> propertiesAnnotations, Map<String, List<AttributeData>> entriesAttributes, boolean doSort) {
// Check if entry has DN property
String dnProperty = getDNPropertyName(entryClass);
// Get DN value
Setter dnSetter = getSetter(entryClass, dnProperty);
if (dnSetter == null) {
throw new MappingException("Entry should has getter for property " + dnProperty);
}
// Type object classes
String[] typeObjectClasses = getTypeObjectClasses(entryClass);
Arrays.sort(typeObjectClasses);
List<T> results = new ArrayList<T>(entriesAttributes.size());
for (Entry<String, List<AttributeData>> entryAttributes : entriesAttributes.entrySet()) {
String dn = entryAttributes.getKey();
List<AttributeData> attributes = entryAttributes.getValue();
Map<String, AttributeData> attributesMap = getAttributesMap(attributes);
T entry;
List<String> customObjectClasses = null;
try {
entry = ReflectHelper.createObjectByDefaultConstructor(entryClass);
} catch (Exception ex) {
throw new MappingException(String.format("Entry %s should has default constructor", entryClass));
}
results.add(entry);
dnSetter.set(entry, dn);
// Remove processed DN attribute
attributesMap.remove(dnProperty);
// Process properties with AttributeName annotation
for (PropertyAnnotation propertiesAnnotation : propertiesAnnotations) {
String propertyName = propertiesAnnotation.getPropertyName();
Annotation ldapAttribute;
ldapAttribute = ReflectHelper.getAnnotationByType(propertiesAnnotation.getAnnotations(), AttributeName.class);
if (ldapAttribute != null) {
String ldapAttributeName = ((AttributeName) ldapAttribute).name();
if (StringHelper.isEmpty(ldapAttributeName)) {
ldapAttributeName = propertyName;
}
ldapAttributeName = ldapAttributeName.toLowerCase();
AttributeData attributeData = attributesMap.get(ldapAttributeName);
// Remove processed attributes
attributesMap.remove(ldapAttributeName);
if (((AttributeName) ldapAttribute).ignoreDuringRead()) {
continue;
}
Setter setter = getSetter(entryClass, propertyName);
if (setter == null) {
throw new MappingException("Entry should has setter for property " + propertyName);
}
Annotation ldapJsonObject = ReflectHelper.getAnnotationByType(propertiesAnnotation.getAnnotations(), JsonObject.class);
boolean jsonObject = ldapJsonObject != null;
setPropertyValue(propertyName, setter, entry, attributeData, jsonObject);
}
}
// Process properties with @AttributesList annotation
for (PropertyAnnotation propertiesAnnotation : propertiesAnnotations) {
String propertyName = propertiesAnnotation.getPropertyName();
Annotation ldapAttribute;
ldapAttribute = ReflectHelper.getAnnotationByType(propertiesAnnotation.getAnnotations(), AttributesList.class);
if (ldapAttribute != null) {
Map<String, AttributeName> ldapAttributesConfiguration = new HashMap<String, AttributeName>();
for (AttributeName ldapAttributeConfiguration : ((AttributesList) ldapAttribute).attributesConfiguration()) {
ldapAttributesConfiguration.put(ldapAttributeConfiguration.name(), ldapAttributeConfiguration);
}
Setter setter = getSetter(entryClass, propertyName);
if (setter == null) {
throw new MappingException("Entry should has setter for property " + propertyName);
}
List<Object> propertyValue = new ArrayList<Object>();
setter.set(entry, propertyValue);
Class<?> entryItemType = ReflectHelper.getListType(setter);
if (entryItemType == null) {
throw new MappingException("Entry property " + propertyName + " should has setter with specified element type");
}
String entryPropertyName = ((AttributesList) ldapAttribute).name();
Setter entryPropertyNameSetter = getSetter(entryItemType, entryPropertyName);
if (entryPropertyNameSetter == null) {
throw new MappingException("Entry should has setter for property " + propertyName + "." + entryPropertyName);
}
String entryPropertyValue = ((AttributesList) ldapAttribute).value();
Setter entryPropertyValueSetter = getSetter(entryItemType, entryPropertyValue);
if (entryPropertyValueSetter == null) {
throw new MappingException("Entry should has getter for property " + propertyName + "." + entryPropertyValue);
}
for (AttributeData entryAttribute : attributesMap.values()) {
if (OBJECT_CLASS.equalsIgnoreCase(entryAttribute.getName())) {
String[] objectClasses = entryAttribute.getStringValues();
if (ArrayHelper.isEmpty(objectClasses)) {
continue;
}
if (customObjectClasses == null) {
customObjectClasses = new ArrayList<String>();
}
for (String objectClass : objectClasses) {
int idx = Arrays.binarySearch(typeObjectClasses, objectClass, new Comparator<String>() {
public int compare(String o1, String o2) {
return o1.toLowerCase().compareTo(o2.toLowerCase());
}
});
if (idx < 0) {
customObjectClasses.add(objectClass);
}
}
continue;
}
AttributeName ldapAttributeConfiguration = ldapAttributesConfiguration.get(entryAttribute.getName());
if ((ldapAttributeConfiguration != null) && ldapAttributeConfiguration.ignoreDuringRead()) {
continue;
}
String entryPropertyMultivalued = ((AttributesList) ldapAttribute).multiValued();
Setter entryPropertyMultivaluedSetter = null;
if (StringHelper.isNotEmpty(entryPropertyMultivalued)) {
entryPropertyMultivaluedSetter = getSetter(entryItemType, entryPropertyMultivalued);
}
if (entryPropertyMultivaluedSetter != null) {
Class<?> parameterType = ReflectHelper.getSetterType(entryPropertyMultivaluedSetter);
if (!parameterType.equals(Boolean.TYPE)) {
throw new MappingException("Entry should has getter for property " + propertyName + "." + entryPropertyMultivalued + " with boolean type");
}
}
Object listItem = getListItem(propertyName, entryPropertyNameSetter, entryPropertyValueSetter, entryPropertyMultivaluedSetter, entryItemType, entryAttribute);
if (listItem != null) {
propertyValue.add(listItem);
}
}
if (doSort) {
sortAttributesListIfNeeded((AttributesList) ldapAttribute, entryItemType, propertyValue);
}
}
}
if ((customObjectClasses != null) && (customObjectClasses.size() > 0)) {
setCustomObjectClasses(entry, entryClass, customObjectClasses.toArray(new String[0]));
}
}
return results;
}
use of io.jans.orm.exception.MappingException in project jans by JanssenProject.
the class BaseEntryManager method isUseEntryForceUpdate.
protected boolean isUseEntryForceUpdate(Class<?> entryClass) {
if (!isSupportForceUpdate()) {
return false;
}
if (entryClass == null) {
throw new MappingException("Entry class is null");
}
// Check if entry is LDAP Entry
List<Annotation> entryAnnotations = ReflectHelper.getClassAnnotations(entryClass, LDAP_ENTRY_TYPE_ANNOTATIONS);
Annotation dataEntry = ReflectHelper.getAnnotationByType(entryAnnotations, DataEntry.class);
if (dataEntry == null) {
return false;
}
return ((DataEntry) dataEntry).forceUpdate();
}
use of io.jans.orm.exception.MappingException in project jans by JanssenProject.
the class BaseEntryManager method merge.
@SuppressWarnings("unchecked")
protected Void merge(Object entry, boolean isSchemaUpdate, boolean isConfigurationUpdate, AttributeModificationType schemaModificationType) {
if (entry == null) {
throw new MappingException("Entry to persist is null");
}
Class<?> entryClass = entry.getClass();
checkEntryClass(entryClass, isSchemaUpdate);
// Determine entry update method
boolean forceUpdate = isUseEntryForceUpdate(entryClass);
String[] objectClasses = getObjectClasses(entry, entryClass);
List<PropertyAnnotation> propertiesAnnotations = getEntryPropertyAnnotations(entryClass);
Map<String, PropertyAnnotation> propertiesAnnotationsMap = prepareEntryPropertiesTypes(entryClass, propertiesAnnotations);
Object dnValue = getDNValue(entry, entryClass);
Integer expirationValue = getExpirationValue(entry, entryClass, true);
List<AttributeData> attributesToPersist = getAttributesListForPersist(entry, propertiesAnnotations);
Map<String, AttributeData> attributesToPersistMap = getAttributesMap(attributesToPersist);
// Load entry
List<AttributeData> attributesFromLdap = null;
if (isSchemaUpdate || forceUpdate) {
// If it's schema modification request we don't need to load
// attributes from LDAP
attributesFromLdap = new ArrayList<AttributeData>();
} else {
List<String> currentLdapReturnAttributesList = buildAttributesListForUpdate(entry, objectClasses, propertiesAnnotations);
if (!isConfigurationUpdate) {
currentLdapReturnAttributesList.add("objectClass");
}
attributesFromLdap = find(dnValue.toString(), objectClasses, propertiesAnnotationsMap, currentLdapReturnAttributesList.toArray(EMPTY_STRING_ARRAY));
}
if (LOG.isTraceEnabled()) {
dumpAttributes("attributesFromLdap", attributesFromLdap);
dumpAttributes("attributesToPersist", attributesToPersist);
}
Map<String, AttributeData> attributesFromLdapMap = getAttributesMap(attributesFromLdap);
// Prepare list of modifications
// Process properties with Attribute annotation
List<AttributeDataModification> attributeDataModifications = collectAttributeModifications(propertiesAnnotations, attributesToPersistMap, attributesFromLdapMap, isSchemaUpdate, schemaModificationType, forceUpdate);
if (LOG.isTraceEnabled()) {
dumpAttributeDataModifications("attributeDataModifications before updateMergeChanges", attributeDataModifications);
}
updateMergeChanges(dnValue.toString(), entry, isSchemaUpdate | isConfigurationUpdate, entryClass, attributesFromLdapMap, attributeDataModifications, forceUpdate);
if (LOG.isTraceEnabled()) {
dumpAttributeDataModifications("attributeDataModifications after updateMergeChanges", attributeDataModifications);
}
LOG.debug(String.format("LDAP attributes for merge: %s", attributeDataModifications));
merge(dnValue.toString(), objectClasses, attributeDataModifications, expirationValue);
return null;
}
Aggregations